chore(tools): tighten the computer tool descriptions to fit the schema budget

The window parameter on computer_read and computer_act put the built-in schemas 14
tokens over their budget. Shorten wording in the two descriptions instead of
widening the budget, and regenerate docs/TOOL_CONTRACT.md.

.gitattributes

@@ -5,7 +5,6 @@
 *.bat text eol=crlf
 *.css text eol=lf
 *.go text eol=lf
-*.golden text eol=lf
 *.html text eol=lf
 *.js text eol=lf
 *.json text eol=lf
@@ -26,8 +25,6 @@
 *.xml text eol=lf
 *.yaml text eol=lf
 *.yml text eol=lf
-Makefile text eol=lf
 .githooks/** text eol=lf
 benchmarks/**/*.sh text eol=lf
 internal/runtime/agent/testdata/perseveration/** -text
-desktop/frontend-next/perf/media/delivery.pdf binary

.github/pr-authors.txt

@@ -1,7 +0,0 @@
-# Logins allowed to open pull requests, one per line, matched case-insensitively.
-# Repository owners, members and collaborators, and bots, are always allowed.
-lancy69
-chuiwenwei
-xxoingr
-kevin9327
-imcreazy

.github/pull_request_template.md

@@ -2,9 +2,6 @@
 Target branch: 2.x features and fixes go to `studio`. 1.x takes bug fixes,
 provider/API compatibility, release/updater, security and platform stability
 only, on `main-v2`.
-
-Pull requests are limited to maintainers and invited contributors; one from
-anyone else is closed automatically. Open an issue instead.
 -->
 
 ## Summary

.github/workflows/acp-conformance.yml

@@ -1,37 +0,0 @@
-name: acp-conformance
-
-# The agent is driven over stdio by the official ACP TypeScript SDK, and every
-# message it writes is held to the schema that SDK ships. Not a required check:
-# it runs when the ACP frontend or the harness changes, and on request.
-on:
-  pull_request:
-    branches: [main-v2, studio]
-    paths:
-      - "internal/frontend/acp/**"
-      - "tools/acp-conformance/**"
-      - ".github/workflows/acp-conformance.yml"
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: acp-conformance-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  conformance:
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
-        with:
-          persist-credentials: false
-      - uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7
-        with:
-          go-version-file: go.mod
-          cache: true
-      - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7
-        with:
-          node-version: "22"
-      - run: make acp-conformance

.github/workflows/android.yml

@@ -1,293 +0,0 @@
-name: Android
-
-# The Android shell under `android/` ships from the same tag the desktop line
-# publishes, and lands on the same release page.
-#
-# It is a separate workflow rather than a job inside release-studio.yml for two
-# reasons. The toolchains share nothing — Go, the Android SDK, a Gradle wrapper —
-# so a runner carrying both would install three toolchains to build one artifact.
-# And `signing-contract` pins which workflows may reach the SignPath credentials;
-# this one never touches them, and keeping it out of that graph is what keeps the
-# fingerprint stable.
-#
-# A failure here does not hold back the desktop release: the two are independent
-# by construction, and an APK is worth less than the desktop builds it sits
-# beside.
-on:
-  push:
-    tags: ['studio-v*']
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: "Existing studio tag to build for and attach to (for example studio-v2.51.0)"
-        required: false
-        type: string
-      ref:
-        description: "A branch to build as a trial run of this workflow; nothing is attached to any release"
-        required: false
-        type: string
-
-permissions:
-  contents: write # upload the APK to the release the tag belongs to
-
-concurrency:
-  group: android-${{ inputs.tag || inputs.ref || github.ref_name }}
-  cancel-in-progress: false
-
-jobs:
-  resolve:
-    name: resolve the tag
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    outputs:
-      tag: ${{ steps.release.outputs.tag }}
-      version: ${{ steps.release.outputs.version }}
-      sha: ${{ steps.release.outputs.sha }}
-      candidate: ${{ steps.release.outputs.candidate }}
-      publish: ${{ steps.release.outputs.publish }}
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
-        with:
-          fetch-depth: 0
-          persist-credentials: false
-
-      # The same tag grammar release-studio.yml enforces, spelled the same way:
-      # two workflows that disagree about which tags name a release would publish
-      # one artifact for a tag the other refused.
-      - name: Resolve tag and version
-        id: release
-        env:
-          IN_TAG: ${{ inputs.tag }}
-          IN_REF: ${{ inputs.ref }}
-          REF_NAME: ${{ github.ref_name }}
-        run: |
-          # A trial run builds a branch as a throwaway version and publishes nothing.
-          if [ -n "$IN_REF" ] && [ -z "$IN_TAG" ]; then
-            sha="$(git rev-parse --verify "origin/$IN_REF^{commit}")"
-            { echo "tag="; echo "version=v0.0.0-dev.${sha:0:7}"; echo "sha=$sha"
-              echo "candidate=false"; echo "publish=false"; } >> "$GITHUB_OUTPUT"
-            echo "trial build of $IN_REF at $sha"
-            exit 0
-          fi
-          tag="${IN_TAG:-$REF_NAME}"
-          semver='^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-([0-9A-Za-z-]+)(\.[0-9A-Za-z-]+)*)?$'
-          if [[ ! "$tag" =~ ^studio-v(.+)$ ]] || [[ ! "${BASH_REMATCH[1]}" =~ $semver ]]; then
-            echo "::error::studio release tag must be studio-vMAJOR.MINOR.PATCH[-PRERELEASE], got: $tag"
-            exit 1
-          fi
-          sha="$(git rev-parse --verify "refs/tags/$tag^{commit}")"
-          if ! git merge-base --is-ancestor "$sha" origin/studio; then
-            echo "::error::$tag is not on studio history"
-            exit 1
-          fi
-          version="${tag#studio-}"
-          candidate=false
-          if [[ "${version#v}" =~ $semver ]] && [ -n "${BASH_REMATCH[4]}" ]; then
-            candidate=true
-          fi
-          { echo "tag=$tag"; echo "version=$version"; echo "sha=$sha"
-            echo "candidate=$candidate"; echo "publish=true"; } >> "$GITHUB_OUTPUT"
-          echo "resolved $tag -> $version at $sha (candidate=$candidate)"
-
-  build:
-    name: build the APK
-    needs: resolve
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    # `publish` decides whether to attach anything, and the only honest answer to
-    # "will this APK install" is whether a key was restored.
-    outputs:
-      signed: ${{ steps.key.outputs.signed }}
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
-        with:
-          ref: ${{ needs.resolve.outputs.sha }}
-          fetch-depth: 0
-          persist-credentials: false
-
-      - uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7
-        with:
-          go-version-file: go.mod
-          cache: true
-          cache-dependency-path: go.sum
-
-      # pnpm first: setup-node's pnpm cache needs the executable to exist.
-      - uses: pnpm/action-setup@ea17c68df8912ef543352723c149a84f56e3d413 # v4
-        with:
-          version: 10
-
-      - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7
-        with:
-          node-version: "24"
-          cache: pnpm
-          cache-dependency-path: desktop/frontend-next/pnpm-lock.yaml
-
-      - uses: actions/setup-java@b843ebf9b913146b38da2eaa7aeddf76074ae1ad # v6.1.0
-        with:
-          distribution: temurin
-          java-version: "21"
-          cache: gradle
-
-      # The SDK is the one thing nothing sets for you, per android/README.md. The
-      # runner image carries one; this asserts the two pieces the build names
-      # rather than re-installing them, so a missing package fails here by name
-      # instead of surfacing later as an unresolved compileSdk.
-      - name: Provide the Android SDK
-        run: |
-          if [ -z "${ANDROID_HOME:-}" ]; then
-            echo "::error::ANDROID_HOME is unset; the runner image is expected to provide the Android SDK"
-            exit 1
-          fi
-          for piece in "platforms/android-35" "build-tools/35.0.0"; do
-            if [ ! -d "$ANDROID_HOME/$piece" ]; then
-              echo "::error::the Android SDK at $ANDROID_HOME has no $piece; android/README.md names it as a requirement"
-              exit 1
-            fi
-          done
-          echo "ANDROID_SDK_ROOT=$ANDROID_HOME" >> "$GITHUB_ENV"
-
-      # A key that exists signs; a key that does not leaves the artifact
-      # unsigned, which is what a release with no key has always produced. The
-      # decision is the repository's, not this workflow's: it reads the four
-      # secrets android/README.md already names.
-      - name: Restore the signing key
-        id: key
-        env:
-          KEYSTORE_BASE64: ${{ secrets.REASONIX_KEYSTORE_BASE64 }}
-          STORE_PASSWORD: ${{ secrets.REASONIX_KEYSTORE_PASSWORD }}
-          KEY_PASSWORD: ${{ secrets.REASONIX_KEY_PASSWORD }}
-          KEY_ALIAS: ${{ secrets.REASONIX_KEY_ALIAS }}
-        run: |
-          if [ -z "$KEYSTORE_BASE64" ] || [ -z "$STORE_PASSWORD" ] || [ -z "$KEY_ALIAS" ]; then
-            echo "signed=false" >> "$GITHUB_OUTPUT"
-            echo "no signing key configured: the APK will be unsigned"
-            exit 0
-          fi
-          mkdir -p android/keystore
-          printf '%s' "$KEYSTORE_BASE64" | base64 --decode > android/keystore/release.jks
-          {
-            echo "storeFile=keystore/release.jks"
-            echo "storePassword=${STORE_PASSWORD}"
-            echo "keyAlias=${KEY_ALIAS}"
-            # PKCS#12 keystores use one password for both; only write the second
-            # when it is genuinely a different fact.
-            [ -n "$KEY_PASSWORD" ] && echo "keyPassword=${KEY_PASSWORD}"
-          } > android/keystore/keystore.properties
-          chmod 600 android/keystore/*
-          echo "signed=true" >> "$GITHUB_OUTPUT"
-          echo "signing key restored"
-
-      - name: Build the kernel and the page
-        working-directory: android
-        env:
-          VERSION: ${{ needs.resolve.outputs.version }}
-        run: |
-          export REASONIX_APP_VERSION="${VERSION#v}"
-          bash ./scripts/build-kernel.sh
-          bash ./scripts/sync-page.sh
-
-      # The one end-to-end check that needs no phone: the kernel the shell starts,
-      # serving the page the APK carries. Running it here means an APK that would
-      # open blank fails the build instead of the install.
-      - name: Verify the packaged page
-        working-directory: android
-        run: |
-          (cd .. && go build -o reasonix-verify ./cmd/reasonix)
-          KERNEL_BIN="$PWD/../reasonix-verify" bash ./scripts/verify-page.sh
-
-      - name: Assemble
-        working-directory: android
-        env:
-          VERSION: ${{ needs.resolve.outputs.version }}
-        run: |
-          # The version comes from the tag, so the About screen and the update
-          # check name this release. versionCode keeps its existing shape, which
-          # is why the build digit stays 1: it is a single decimal place, and a
-          # number that grows past it would collide with the next patch.
-          ./gradlew assembleRelease --no-daemon "-PreasonixVersion=${VERSION#v}"
-
-      - name: Name the artifact
-        id: apk
-        working-directory: android/app/build/outputs/apk/release
-        run: |
-          src="$(ls ./*.apk | head -n 1)"
-          if [ -z "$src" ]; then
-            echo "::error::assembleRelease produced no APK"
-            exit 1
-          fi
-          case "$src" in
-            *-unsigned.apk) name="ReasonixMobile-${{ needs.resolve.outputs.version }}-unsigned.apk" ;;
-            *)              name="ReasonixMobile-${{ needs.resolve.outputs.version }}.apk" ;;
-          esac
-          mv "$src" "$name"
-          sha256sum "$name" > "$name.sha256"
-          {
-            echo "path=$PWD/$name"
-            echo "name=$name"
-          } >> "$GITHUB_OUTPUT"
-          ls -l "$name" "$name.sha256"
-
-      # An unsigned package is not a lesser APK, it is an unusable one: Android's
-      # package manager rejects it outright rather than reporting a signature
-      # mismatch. Say so where the run summary can be read, instead of letting a
-      # green build imply a shippable artifact.
-      - name: Say what an unsigned build means
-        if: steps.key.outputs.signed != 'true'
-        run: |
-          echo "::warning::no signing key configured, so this APK is unsigned. Android refuses to install an unsigned package, so the release will carry no APK; the file stays a workflow artifact for whoever signs it."
-          {
-            echo "### No APK on this release"
-            echo ""
-            echo "The build produced an unsigned APK, which Android refuses to install."
-            echo "It is attached to this run as a workflow artifact only. Add the four"
-            echo "signing secrets to publish one."
-          } >> "$GITHUB_STEP_SUMMARY"
-
-      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v8
-        with:
-          name: android-apk
-          path: |
-            android/app/build/outputs/apk/release/*.apk
-            android/app/build/outputs/apk/release/*.sha256
-          if-no-files-found: error
-
-  publish:
-    name: attach the APK
-    needs: [resolve, build]
-    # Nothing to attach unless the build was signed. Skipping is the honest
-    # outcome: a release page with an APK nobody can install is worse than a
-    # release page without one.
-    if: needs.build.outputs.signed == 'true' && needs.resolve.outputs.publish == 'true'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
-        with:
-          name: android-apk
-          path: dist
-
-      # The release itself belongs to release-studio.yml, which creates it and
-      # owns its notes. This waits for it rather than creating a second one: two
-      # jobs racing to define a release is how a page ends up with the wrong body.
-      - name: Attach to the release
-        env:
-          GH_TOKEN: ${{ github.token }}
-          TAG: ${{ needs.resolve.outputs.tag }}
-          REPO: ${{ github.repository }}
-        run: |
-          # 90 minutes: on the last Studio release the page appeared about 40
-          # minutes after the tag run started, and the APK build spends part of
-          # that before this wait begins.
-          for _ in $(seq 1 360); do
-            if gh release view "$TAG" --repo "$REPO" >/dev/null 2>&1; then
-              gh release upload "$TAG" dist/*.apk dist/*.sha256 --repo "$REPO" --clobber
-              echo "attached to $TAG"
-              exit 0
-            fi
-            sleep 15
-          done
-          echo "::error::release $TAG did not appear within 90 minutes; the APK was built but not published"
-          exit 1

.github/workflows/ci.yml

@@ -15,7 +15,7 @@ permissions:
 
 concurrency:
   group: ci-${{ github.ref }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' || github.ref == 'refs/heads/studio' }}
+  cancel-in-progress: true
 
 jobs:
   # Cheap path gate for pull requests. PRs confined to docs/release-notes
@@ -88,7 +88,7 @@ jobs:
         with:
           go-version-file: go.mod
           cache: true
-      - run: node --test scripts/linux-install-smoke.test.mjs scripts/studio-artifacts.test.mjs scripts/ci-platform-scope.test.mjs scripts/cli-archive-build.test.mjs scripts/cli-archive-contents.test.mjs scripts/release-credits.test.mjs scripts/update-contributors.test.mjs scripts/update-acknowledgments.test.mjs scripts/markdown-refs.test.mjs scripts/studio-release-notes.test.mjs scripts/publish-cli-pointer.test.mjs scripts/studio-release-flags.test.mjs scripts/studio-notes-publish.test.mjs scripts/withdraw-version.test.mjs scripts/brew-cask-guard.test.mjs scripts/feedback-sync.test.mjs npm/publish.test.mjs
+      - run: node --test scripts/ci-platform-scope.test.mjs scripts/cli-archive-build.test.mjs scripts/release-credits.test.mjs scripts/update-contributors.test.mjs scripts/update-acknowledgments.test.mjs scripts/markdown-refs.test.mjs scripts/studio-release-notes.test.mjs scripts/publish-cli-pointer.test.mjs scripts/studio-release-flags.test.mjs scripts/studio-notes-publish.test.mjs scripts/brew-cask-guard.test.mjs scripts/feedback-sync.test.mjs npm/publish.test.mjs
 
   # The ruleset requires the per-OS check names (test (ubuntu-latest) etc.).
   # A matrix job skipped at job level reports no per-leg checks at all, so
@@ -179,27 +179,9 @@ jobs:
           REASONIX_RELEASE_CACHE_GUARD: "1"
         run: go test ./...
 
-      - name: test (Windows composition links)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(CaptureDirectoryMaterializesContainedLinks|CaptureDirectoryRefusesUnsafeLinks|CaptureHookFileFlattensContainedLink|MaterializeStillRejectsLinkedRetainedFilesAndRoot|WindowsCompositionJunctions|WindowsLiveSkillJunctions|CompositionRetainsLinkedSkillAcrossRestart|CompositionLinkedSkillRejectsLinkedResources|CompositionLinkedExtensionResources|CompositionLinkedHookResources)$' ./internal/state/agentpreset ./internal/ext/skill ./internal/assembly/boot | tee "$RUNNER_TEMP/composition-links.jsonl"
-          jq -se '
-            ["TestCaptureDirectoryMaterializesContainedLinks", "TestCaptureDirectoryRefusesUnsafeLinks",
-             "TestCaptureHookFileFlattensContainedLink", "TestMaterializeStillRejectsLinkedRetainedFilesAndRoot",
-             "TestWindowsCompositionJunctions", "TestWindowsLiveSkillJunctions", "TestCompositionRetainsLinkedSkillAcrossRestart",
-             "TestCompositionLinkedSkillRejectsLinkedResources", "TestCompositionLinkedExtensionResources",
-             "TestCompositionLinkedHookResources"] as $required |
-            [.[] | select(.Action == "pass") | .Test] as $passed |
-            all(.[]; .Action != "skip") and (($required - $passed) | length == 0)
-          ' "$RUNNER_TEMP/composition-links.jsonl"
-
       # Pull requests run a Windows smoke suite: the packages that actually
       # carry *_windows.go code, the startup/checkpoint packages with portable
-      # filesystem contracts, plus cmd/. Isolation/worktree/mutation have a
-      # complete JSON inventory below. The full ./... sweep stays on pushes
+      # filesystem contracts, plus cmd/. The full ./... sweep stays on pushes
       # to main-v2; the Unix legs always run the full suite. Keep the job-level
       # budget above normal 7-9 minute runner variance; each package test binary
       # remains independently bounded by Go's per-package timeout below.
@@ -223,543 +205,6 @@ jobs:
           WINDOWS_SANDBOX_WAIT_MS: "20000"
         run: go test -count=1 -p 4 -timeout=18m ./internal/runtime/agent/... ./internal/platform/appidentity/... ./internal/assembly/boot/... ./internal/state/checkpoint/... ./internal/frontend/cli/... ./internal/session/control/... ./internal/base/filelock/... ./internal/base/fileutil/... ./internal/ext/hook/... ./internal/state/instruction/... ./internal/ext/mcplaunch/... ./internal/platform/notify/... ./internal/base/proc/... ./internal/platform/remote/... ./internal/platform/repair/... ./internal/safety/sandbox/... ./internal/base/sysproxy/... ./internal/state/workspacelease/... ./cmd/...
 
-      - name: test (Windows published command job owner)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        shell: bash
-        run: |
-          set -euo pipefail
-          evidence="$RUNNER_TEMP/published-job-owner"
-          mkdir -p "$evidence"
-          go test -count=1 -timeout=3m -json -run '^TestPublishedJob' ./internal/base/proc | tee "$evidence/positive.jsonl"
-          node scripts/published-job-evidence.mjs positive "$evidence/positive.jsonl"
-          node scripts/published-job-evidence.mjs overlay "$evidence"
-          set +e
-          go test -count=1 -timeout=3m -json -overlay="$evidence/overlay.json" -run '^TestPublishedJob' ./internal/base/proc > "$evidence/negative.jsonl"
-          old_result=$?
-          set -e
-          test "$old_result" -eq 1
-          node scripts/published-job-evidence.mjs negative "$evidence/negative.jsonl"
-
-      - name: upload Windows published command job owner evidence
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: published-job-owner-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/published-job-owner/
-          if-no-files-found: error
-          retention-days: 7
-
-      - name: test (Windows isolation owners)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 25
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -p 4 -timeout=18m -json ./internal/platform/worktree/... ./internal/state/mutation/... | tee "$RUNNER_TEMP/isolation-owners.jsonl" |
-            jq -rj --unbuffered 'select(.Action == "output" and .Test == null) | .Output'
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $passed |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            (["reasonix/internal/platform/worktree", "reasonix/internal/state/mutation"] - $passed | length) == 0 and
-            (["TestHeldPathsCoverOnlyTheSameFileAcrossCaseSpellings",
-              "TestLegacyWaitDoesNotConsumeExecutionCapacity"] - $tests | length) == 0
-          ' "$RUNNER_TEMP/isolation-owners.jsonl"
-          jq -se '
-            . as $events |
-            {"reasonix/internal/platform/worktree": [
-               "TestWriteChangesRejectsRedirectedDeletion",
-               "TestWriteChangesUnlinksLeafDirectoryLink"
-               ]} |
-            to_entries | all(.[]; . as $package |
-              ([ $events[] | select(.Package == $package.key and .Test == null and
-                 (.Action == "pass" or .Action == "fail" or .Action == "skip")) ] |
-               length == 1 and .[0].Action == "pass") and
-              all(.value[]; . as $test |
-                [ $events[] | select(.Package == $package.key and .Test == $test and
-                  (.Action == "pass" or .Action == "fail" or .Action == "skip")) ] |
-                length == 1 and .[0].Action == "pass"))
-          ' "$RUNNER_TEMP/isolation-owners.jsonl"
-
-      - name: upload Windows isolation test inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: isolation-owners-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/isolation-owners.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
-      - name: test (Windows delegated Goal usage scope)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(UsageScope.*)$' ./internal/contract/event ./internal/session/control ./internal/assembly/boot | tee "$RUNNER_TEMP/goal-usage-scope.jsonl"
-          jq -se '
-            ["TestUsageScopeKeepsEarlierEventOwner",
-             "TestUsageScopeWithoutCapability" ] as $required |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $passed |
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            all(.[]; .Action != "fail" and .Action != "skip") and
-            (($required - $passed) | length == 0) and
-            ((["reasonix/internal/contract/event", "reasonix/internal/session/control", "reasonix/internal/assembly/boot"] - $packages) | length == 0)
-          ' "$RUNNER_TEMP/goal-usage-scope.jsonl"
-
-      - name: upload Windows delegated Goal usage scope inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: goal-usage-scope-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/goal-usage-scope.jsonl
-          if-no-files-found: error
-          retention-days: 7
-
-      - name: test (Windows Controller routing root budget)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(SemanticRootUsage)$' ./internal/runtime/capability | tee "$RUNNER_TEMP/controller-routing-budget.jsonl"
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            all(.[]; .Action != "skip" and .Action != "fail") and
-            (["reasonix/internal/runtime/capability"] - $packages | length) == 0 and
-            ([
-              "TestSemanticRootUsage",
-              "TestSemanticRootUsage/billed_error",
-              "TestSemanticRootUsage/cache",
-              "TestSemanticRootUsage/estimated",
-              "TestSemanticRootUsage/invalid_answer",
-              "TestSemanticRootUsage/missing",
-              "TestSemanticRootUsage/nil_sink",
-              "TestSemanticRootUsage/no_observer",
-              "TestSemanticRootUsage/reported"
-            ] - $tests | length) == 0
-          ' "$RUNNER_TEMP/controller-routing-budget.jsonl"
-
-      - name: upload Windows Controller routing root budget inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: controller-routing-budget-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/controller-routing-budget.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
-      - name: test (Windows Coordinator root budget)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(PreparedRootBudget|CoordinatorRootBudget|EffectCoordinatorRoot)' ./internal/runtime/agent ./internal/runtime/coordinator | tee "$RUNNER_TEMP/coordinator-root-budget.jsonl"
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            all(.[]; .Action != "skip" and .Action != "fail") and
-            (["reasonix/internal/runtime/agent", "reasonix/internal/runtime/coordinator"] - $packages | length) == 0 and
-            (["TestCoordinatorRootBudgetRoutes",
-              "TestCoordinatorRootBudgetRoutes/raw", "TestCoordinatorRootBudgetRoutes/tool_planner",
-              "TestCoordinatorRootBudgetRoutes/failure_fallback", "TestCoordinatorRootBudgetRoutes/plan_only_continuation",
-              "TestCoordinatorRootBudgetRoutes/approval_declined_continuation", "TestCoordinatorRootBudgetRoutes/approval_allowed"
-              ] - $tests | length) == 0
-          ' "$RUNNER_TEMP/coordinator-root-budget.jsonl"
-
-      - name: upload Windows Coordinator root budget inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: coordinator-root-budget-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/coordinator-root-budget.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
-      - name: test (Windows resumed Goal planner budget)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(GoalResumeRenewsPlannerBudget|GoalNonBudgetResumeKeepsPlannerBudget|GoalTokenBudgetPausesAndResumes|EffectGoalResumeRenewsPlannerBudget)$' ./internal/session/control ./internal/assembly/boot | tee "$RUNNER_TEMP/goal-planner-resume.jsonl"
-          jq -se '
-            ["TestGoalResumeRenewsPlannerBudget",
-             "TestGoalNonBudgetResumeKeepsPlannerBudget",
-             "TestGoalNonBudgetResumeKeepsPlannerBudget/manual_pause",
-             "TestGoalNonBudgetResumeKeepsPlannerBudget/not_resumable",
-             "TestGoalTokenBudgetPausesAndResumes",
-             "TestEffectGoalResumeRenewsPlannerBudget"] as $required |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $passed |
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            all(.[]; .Action != "fail" and .Action != "skip") and
-            (($required - $passed) | length == 0) and
-            ((["reasonix/internal/session/control", "reasonix/internal/assembly/boot"] - $packages) | length == 0)
-          ' "$RUNNER_TEMP/goal-planner-resume.jsonl"
-
-      - name: upload Windows resumed Goal planner budget inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: goal-planner-resume-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/goal-planner-resume.jsonl
-          if-no-files-found: error
-          retention-days: 7
-
-      - name: test (Windows root wall budget)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(RootWall|EffectRootWall)' ./internal/runtime/agent ./internal/assembly/boot | tee "$RUNNER_TEMP/root-wall-budget.jsonl"
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            all(.[]; .Action != "skip" and .Action != "fail") and
-            (["reasonix/internal/runtime/agent", "reasonix/internal/assembly/boot"] - $packages | length) == 0 and
-            (["TestRootWallBudgetReachesDelegatedAgents", "TestRootWallBudgetReachesDelegatedAgents/foreground",
-              "TestRootWallBudgetReachesDelegatedAgents/nested", "TestRootWallBudgetReachesDelegatedAgents/siblings",
-              "TestRootWallBudgetReachesDelegatedAgents/context", "TestRootWallBudgetReachesDelegatedAgents/unconfigured",
-              "TestRootWallBudgetReachesDelegatedAgents/explicit_zero", "TestRootWallBudgetContinuationAndReset",
-              "TestRootWallBudgetContinuationAndReset/continuation", "TestRootWallBudgetContinuationAndReset/new_task",
-              "TestRootWallBudgetContinuationAndReset/reset", "TestRootWallBudgetContinuationAndReset/override"
-              ] - $tests | length) == 0
-          ' "$RUNNER_TEMP/root-wall-budget.jsonl"
-
-      - name: upload Windows root wall budget inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: root-wall-budget-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/root-wall-budget.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
-      - name: test (Windows root token budget)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(RootToken|EffectRootToken|BudgetCountsKnownReportedTokens|ReportedToken)' ./internal/runtime/agent | tee "$RUNNER_TEMP/root-token-budget.jsonl"
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            all(.[]; .Action != "skip" and .Action != "fail") and
-            (["reasonix/internal/runtime/agent"] - $packages | length) == 0 and
-            (["TestRootTokenBudgetIncludesChildProviderUsage", "TestRootTokenBudgetIncludesChildProviderUsage/configured",
-              "TestRootTokenBudgetIncludesChildProviderUsage/context", "TestRootTokenBudgetIncludesChildProviderUsage/unconfigured",
-              "TestRootTokenBudgetIncludesChildProviderUsage/explicit_zero", "TestRootTokenBudgetSurvivesNestedAndConcurrentChildren",
-              "TestRootTokenBudgetSurvivesNestedAndConcurrentChildren/nested", "TestRootTokenBudgetSurvivesNestedAndConcurrentChildren/siblings",
-              "TestRootTokenBudgetSurvivesNestedAndConcurrentChildren/child_override", "TestRootTokenBudgetContinuationAndReset",
-              "TestRootTokenBudgetContinuationAndReset/continuation", "TestRootTokenBudgetContinuationAndReset/new_task",
-              "TestRootTokenBudgetContinuationAndReset/reset" ] - $tests | length) == 0
-          ' "$RUNNER_TEMP/root-token-budget.jsonl"
-          jq -se '
-            . as $events |
-            {"reasonix/internal/runtime/agent": [
-               "TestBudgetCountsKnownReportedTokens",
-               "TestBudgetCountsKnownReportedTokens/split",
-               "TestBudgetCountsKnownReportedTokens/total_only",
-               "TestBudgetCountsKnownReportedTokens/partial_split",
-               "TestBudgetCountsKnownReportedTokens/lower_total",
-               "TestBudgetCountsKnownReportedTokens/missing_total",
-               "TestBudgetCountsKnownReportedTokens/negative_split",
-               "TestBudgetCountsKnownReportedTokens/zero",
-               "TestBudgetCountsKnownReportedTokens/negative",
-               "TestReportedTokenCountersSaturate"]} |
-            to_entries | all(.[]; . as $package |
-              ([ $events[] | select(.Package == $package.key and .Test == null and
-                 (.Action == "pass" or .Action == "fail" or .Action == "skip")) ] |
-               length == 1 and .[0].Action == "pass") and
-              all(.value[]; . as $test |
-                [ $events[] | select(.Package == $package.key and .Test == $test and
-                  (.Action == "pass" or .Action == "fail" or .Action == "skip")) ] |
-                length == 1 and .[0].Action == "pass"))
-          ' "$RUNNER_TEMP/root-token-budget.jsonl"
-
-      - name: upload Windows root token budget inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: root-token-budget-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/root-token-budget.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
-      - name: test (Windows budget usage completeness)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(RequestOnlyUsage|RunBudgetMissingUsage|TaskBudgetKnownCost|RunBudgetExplicitZero|TaskBudgetUsageCompleteness|TaskBudgetCostUses|EffectBudgetCompleteness|TaskBudgetGateIgnoresCostWhenUnpriced)' ./internal/contract/provider ./internal/runtime/agent ./internal/assembly/boot | tee "$RUNNER_TEMP/budget-usage.jsonl"
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            all(.[]; .Action != "skip" and .Action != "fail") and
-            (["reasonix/internal/contract/provider", "reasonix/internal/runtime/agent", "reasonix/internal/assembly/boot"] - $packages | length) == 0 and
-            (["TestRequestOnlyUsageDoesNotCertifyTokenAccounting", "TestRunBudgetMissingUsageKeepsCostIncomplete",
-              "TestRunBudgetMissingUsageKeepsCostIncomplete/complete", "TestRunBudgetMissingUsageKeepsCostIncomplete/missing_first",
-              "TestRunBudgetMissingUsageKeepsCostIncomplete/missing_last", "TestRunBudgetMissingUsageKeepsCostIncomplete/all_missing",
-              "TestTaskBudgetKnownCostStillLandsAfterMissingUsage", "TestRunBudgetExplicitZeroUsageIsPriced",
-              "TestTaskBudgetUsageCompletenessFollowsItsLifetime", "TestTaskBudgetUsageCompletenessFollowsItsLifetime/continuation",
-              "TestTaskBudgetUsageCompletenessFollowsItsLifetime/new_task", "TestTaskBudgetUsageCompletenessFollowsItsLifetime/explicit_reset",
-              "TestTaskBudgetCostUsesOnlyTheReportedSubtotal", "TestTaskBudgetGateIgnoresCostWhenUnpriced",
-              "TestEffectBudgetCompletenessFromOpenAIStream", "TestEffectBudgetCompletenessFromOpenAIStream/missing_0",
-              "TestEffectBudgetCompletenessFromOpenAIStream/missing_1", "TestEffectBudgetCompletenessFromOpenAIStream/missing_2"] - $tests | length) == 0
-          ' "$RUNNER_TEMP/budget-usage.jsonl"
-
-      - name: upload Windows budget usage inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: budget-usage-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/budget-usage.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
-
-      - name: test (Windows Git storage environment)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(HostStorageEnvironment|HostObjectStorage|HostExplicitStorageControls|DetachedStorageEnvironment)$' ./internal/platform/gitcmd ./internal/platform/worktree ./internal/assembly/boot | tee "$RUNNER_TEMP/git-storage-environment.jsonl"
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            all(.[]; .Action != "skip" and .Action != "fail") and
-            (["reasonix/internal/platform/gitcmd", "reasonix/internal/platform/worktree", "reasonix/internal/assembly/boot"] - $packages | length) == 0 and
-            ([
-              "TestDetachedStorageEnvironment",
-              "TestDetachedStorageEnvironment/explicit_env",
-              "TestDetachedStorageEnvironment/inherited_env",
-              "TestHostExplicitStorageControls",
-              "TestHostExplicitStorageControls/explicit_object_directory",
-              "TestHostExplicitStorageControls/private_index",
-              "TestHostExplicitStorageControls/repository_declared_alternate",
-              "TestHostObjectStorage",
-              "TestHostObjectStorage/ambient_alternate_not_read",
-              "TestHostObjectStorage/writes_stay_in_repository",
-              "TestHostStorageEnvironment",
-              "TestHostStorageEnvironment/GIT_ALTERNATE_OBJECT_DIRECTORIES",
-              "TestHostStorageEnvironment/GIT_INDEX_FILE",
-              "TestHostStorageEnvironment/GIT_OBJECT_DIRECTORY"
-              ] - $tests | length) == 0
-          ' "$RUNNER_TEMP/git-storage-environment.jsonl"
-
-      - name: upload Windows Git storage environment inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: git-storage-environment-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/git-storage-environment.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
-      - name: test (Windows Anthropic interrupted usage)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(InterruptedUsage|EffectAnthropicPartialUsageRecovery)' ./internal/model/anthropic ./internal/assembly/boot | tee "$RUNNER_TEMP/anthropic-interrupted-usage.jsonl"
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            all(.[]; .Action != "skip" and .Action != "fail") and
-            (["reasonix/internal/model/anthropic", "reasonix/internal/assembly/boot"] - $packages | length) == 0 and
-            (["TestInterruptedUsageTerminal", "TestInterruptedUsageTerminal/upstream_error",
-              "TestInterruptedUsageTerminal/payload_error", "TestInterruptedUsageTerminal/premature_eof",
-              "TestInterruptedUsageTerminal/decode_error", "TestInterruptedUsageTerminal/reported_zero",
-              "TestInterruptedUsageTerminal/missing_control", "TestInterruptedUsageTerminal/complete_control",
-              "TestInterruptedUsageBoundedConsumer", "TestInterruptedUsageReadErrorAndCancellation",
-              "TestInterruptedUsageReadErrorAndCancellation/read_error", "TestInterruptedUsageReadErrorAndCancellation/cancelled_buffered_reader",
-              "TestInterruptedUsageAbandonedConsumer", "TestInterruptedUsageIdleTimeout",
-              "TestEffectAnthropicPartialUsageRecovery", "TestEffectAnthropicPartialUsageRecovery/upstream_error",
-              "TestEffectAnthropicPartialUsageRecovery/premature_eof", "TestEffectAnthropicPartialUsageRecovery/complete_control"] - $tests | length) == 0
-          ' "$RUNNER_TEMP/anthropic-interrupted-usage.jsonl"
-
-      - name: upload Windows Anthropic interrupted usage inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: anthropic-interrupted-usage-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/anthropic-interrupted-usage.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
-      - name: test (Windows root websearch budget)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(RootWebSearch|EffectRootWebSearch)' ./internal/tools/websearch | tee "$RUNNER_TEMP/root-websearch-budget.jsonl"
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            all(.[]; .Action != "skip" and .Action != "fail") and
-            (["reasonix/internal/tools/websearch"] - $packages | length) == 0 and
-            (["TestRootWebSearchUsageTerminal", "TestRootWebSearchUsageTerminal/reported",
-              "TestRootWebSearchUsageTerminal/no_reporter", "TestRootWebSearchUsageTerminal/missing",
-              "TestRootWebSearchUsageTerminal/no_observer", "TestRootWebSearchUsageTerminal/input_refused",
-              "TestRootWebSearchUsageTerminal/no_factory", "TestRootWebSearchUsageTerminal/factory_error",
-              "TestRootWebSearchUsageTerminal/billed_failure", "TestRootWebSearchUsageTerminal/cancel_after_usage",
-              "TestRootWebSearchUsageTerminal/cancel_before_start", "TestRootWebSearchUsageTerminal/stream_error"
-              ] - $tests | length) == 0
-          ' "$RUNNER_TEMP/root-websearch-budget.jsonl"
-
-      - name: upload Windows root websearch budget inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: root-websearch-budget-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/root-websearch-budget.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
-      - name: test (Windows explicit skill root budget)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^(TestProfileRootBudgetLifetime|TestProfileBudgetPreparationUsesTurnAdmission|TestEffectExplicitSkillRootBudget)$' ./internal/session/control | tee "$RUNNER_TEMP/explicit-skill-root-budget.jsonl"
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            all(.[]; .Action != "skip" and .Action != "fail") and
-            (["reasonix/internal/session/control"] - $packages | length) == 0 and
-            (["TestProfileBudgetPreparationUsesTurnAdmission" ] - $tests | length) == 0
-          ' "$RUNNER_TEMP/explicit-skill-root-budget.jsonl"
-
-      - name: upload Windows explicit skill root budget inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: explicit-skill-root-budget-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/explicit-skill-root-budget.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
-      - name: test (Windows root triage budget)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(RootTriage|EffectRootTriage)' ./internal/runtime/agent | tee "$RUNNER_TEMP/root-triage-budget.jsonl"
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            all(.[]; .Action != "skip" and .Action != "fail") and
-            (["reasonix/internal/runtime/agent"] - $packages | length) == 0 and
-            (["TestRootTriageTokenBudget", "TestRootTriageTokenBudget/classifier", "TestRootTriageTokenBudget/screen",
-              "TestRootTriageTokenBudget/billed_failure", "TestRootTriageTokenBudget/missing", "TestRootTriageTokenBudget/disabled",
-              "TestRootTriageTokenBudget/no_sink", "TestRootTriageTokenBudget/counts_without_total",
-              "TestRootTriageOutsideRunDoesNotCreateScope" ] - $tests | length) == 0
-          ' "$RUNNER_TEMP/root-triage-budget.jsonl"
-
-      - name: upload Windows root triage budget inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: root-triage-budget-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/root-triage-budget.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
-      - name: test (Windows local cost quote)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(LocalBudgetUsesOccurrenceQuote|LocalCost.*|UsageQuote.*)$' ./internal/contract/event ./internal/runtime/agent | tee "$RUNNER_TEMP/local-cost-quote.jsonl"
-          jq -se '
-            ["TestLocalBudgetUsesOccurrenceQuote", "TestLocalBudgetUsesOccurrenceQuote/peak", "TestLocalBudgetUsesOccurrenceQuote/offpeak",
-             "TestLocalCostKeepsOriginalCurrencyBuckets", "TestLocalCostFixedPointThresholdAndUnknown",
-             "TestUsageQuoteUsesOneOwnerAndOccurrence", "TestUsageQuoteLegacyAndNilSinks"
-             ] as $required |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $passed |
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            all(.[]; .Action != "fail" and .Action != "skip") and
-            (($required - $passed) | length == 0) and
-            ((["reasonix/internal/contract/event", "reasonix/internal/runtime/agent"] - $packages) | length == 0)
-          ' "$RUNNER_TEMP/local-cost-quote.jsonl"
-
-      - name: upload Windows local cost quote inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: local-cost-quote-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/local-cost-quote.jsonl
-          if-no-files-found: error
-          retention-days: 7
-
-      - name: test (Windows estimated usage quotes)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(EstimatedUsage|EffectEstimatedUsage|ToWireUsagePayloadJSON$|StatusExtensionTracksMultipleSessionsAndUsage$|CacheSplitProvenanceIsRecorded$|RecordedPlainCallIsUnchanged$)' ./internal/contract/pricing ./internal/contract/event ./internal/contract/config ./internal/assembly/boot ./internal/contract/eventwire ./internal/frontend/acp ./internal/state/stats | tee "$RUNNER_TEMP/estimated-quote.jsonl"
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            all(.[]; .Action != "skip" and .Action != "fail") and
-            (["reasonix/internal/contract/pricing", "reasonix/internal/contract/event", "reasonix/internal/contract/config", "reasonix/internal/assembly/boot",
-              "reasonix/internal/contract/eventwire", "reasonix/internal/frontend/acp", "reasonix/internal/state/stats"] - $packages | length) == 0 and
-            (["TestEstimatedUsageQuotePreservesAmountsWithoutCompleteFacts", "TestEstimatedUsageQuotePreservesAmountsWithoutCompleteFacts/CNY",
-              "TestEstimatedUsageQuotePreservesAmountsWithoutCompleteFacts/USD", "TestEstimatedUsageLedgerRetainsPartialCoverage",
-              "TestEstimatedUsageLedgerRetainsPartialCoverage/separate_keys", "TestEstimatedUsageLedgerRetainsPartialCoverage/same_key",
-              "TestEstimatedUsageSavedQuoteReader", "TestEstimatedUsageQuoteSinkCoversTurnAndGuardian",
-              "TestEstimatedUsageQuoteSinkCoversTurnAndGuardian/turn", "TestEstimatedUsageQuoteSinkCoversTurnAndGuardian/guardian",
-              "TestEstimatedUsageConfiguredQuote", "TestEffectEstimatedUsageQuoteAfterStreamRecovery",
-              "TestEffectEstimatedUsageQuoteAfterStreamRecovery/reported_control", "TestEffectEstimatedUsageQuoteAfterStreamRecovery/interrupted",
-              "TestToWireUsagePayloadJSON", "TestStatusExtensionTracksMultipleSessionsAndUsage", "TestCacheSplitProvenanceIsRecorded", "TestRecordedPlainCallIsUnchanged"] - $tests | length) == 0
-          ' "$RUNNER_TEMP/estimated-quote.jsonl"
-
-      - name: upload Windows estimated quote inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: estimated-quote-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/estimated-quote.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
-      - name: test (Windows bounded root budget)
-        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        timeout-minutes: 5
-        shell: bash
-        run: |
-          set -o pipefail
-          go test -count=1 -timeout=3m -json -run '^Test(AuxiliaryUsageObserver|BoundedUsageObserver|RootBounded|EffectRootBounded)' ./internal/contract/provider ./internal/model/boundedllm ./internal/runtime/agent | tee "$RUNNER_TEMP/bounded-root-budget.jsonl"
-          jq -se '
-            [.[] | select(.Test == null and .Action == "pass") | .Package] as $packages |
-            [.[] | select(.Test != null and .Action == "pass") | .Test] as $tests |
-            all(.[]; .Action != "skip" and .Action != "fail") and
-            (["reasonix/internal/contract/provider", "reasonix/internal/model/boundedllm",
-              "reasonix/internal/runtime/agent"] - $packages | length) == 0 and
-            (["TestAuxiliaryUsageObserverReplacesAndCopies",
-              "TestBoundedUsageObserverOwnsOneTerminal", "TestBoundedUsageObserverOwnsOneTerminal/reported",
-              "TestBoundedUsageObserverOwnsOneTerminal/billed_failure", "TestBoundedUsageObserverOwnsOneTerminal/without_sink",
-              "TestBoundedUsageObserverOwnsOneTerminal/missing", "TestBoundedUsageObserverOwnsOneTerminal/input_refused"
-              ] - $tests | length) == 0
-          ' "$RUNNER_TEMP/bounded-root-budget.jsonl"
-
-      - name: upload Windows bounded root budget inventory
-        if: always() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name == 'pull_request'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7
-        with:
-          name: bounded-root-budget-windows-${{ github.run_attempt }}
-          path: ${{ runner.temp }}/bounded-root-budget.jsonl
-          if-no-files-found: ignore
-          retention-days: 7
-
       # The general Windows PR smoke list intentionally omits internal/contract/tool.
       # Keep the session-temp portability contract covered without widening the
       # leg to every tool test: two real PowerShell launches must share the
@@ -777,6 +222,40 @@ jobs:
         timeout-minutes: 5
         run: go test -count=1 -timeout=3m -run '^TestBashPowerShellExecuteDetailedContract$|^TestBashPowerShell51PreflightRejectsAndAndDetailed$|^TestBashPowerShellOutputIsUTF8$|^TestBashPowerShellSurfacesNonZeroExit$|^TestBashPowerShellRejectsChaining$' ./internal/tools/builtin
 
+      # Full push suite uses the same 18m package timeout as Windows smoke and a
+      # 35m step budget above it. -count=1 as at the smoke step. A failure prints
+      # the failed tests' output and the 15 slowest boot tests.
+      - name: test (full)
+        if: env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name != 'pull_request'
+        timeout-minutes: 35
+        env:
+          # Run the prompt-cache prefix-stability guard (TestCacheHit*) in CI: a
+          # regression there silently tanks the cache hit rate the project is
+          # built around.
+          REASONIX_RELEASE_CACHE_GUARD: "1"
+          # Bound sandbox helper children in Windows tests so a failed OS-level
+          # launch cannot pin the Actions step after Go's package timeout fires.
+          WINDOWS_SANDBOX_WAIT_MS: "20000"
+        shell: bash
+        run: |
+          go test -count=1 -p 4 -timeout=18m -json ./... | tee "$RUNNER_TEMP/full.jsonl" |
+            jq -rj --unbuffered 'select(.Action == "output" and .Test == null) | .Output'
+
+      - name: test (full) failure detail
+        if: failure() && env.RUN_STEPS == 'true' && runner.os == 'Windows' && github.event_name != 'pull_request'
+        shell: bash
+        run: |
+          f="$RUNNER_TEMP/full.jsonl"
+          [ -s "$f" ] || exit 0
+          echo "::group::output of failed tests"
+          jq -rn '[inputs | select(.Test != null)] | group_by(.Package + "/" + .Test)
+            | map(select(any(.[]; .Action == "fail")))[]
+            | map(select(.Action == "output") | .Output) | join("")' "$f" || true
+          echo "::endgroup::"
+          echo "slowest internal/assembly/boot tests (seconds, name):"
+          jq -rn '[inputs | select((.Package | endswith("/internal/assembly/boot")) and .Test != null and .Action == "pass")]
+            | sort_by(-.Elapsed)[:15][] | "\(.Elapsed)\t\(.Test)"' "$f" || true
+
   race:
     needs: changes
     if: always() && (github.event_name != 'pull_request' || needs.changes.outputs.code != 'false')
@@ -811,130 +290,13 @@ jobs:
         if: github.event_name == 'pull_request'
         env:
           REASONIX_RELEASE_CACHE_GUARD: "1"
-        run: go test -race ./internal/runtime/agent/... ./internal/runtime/delegation/... ./internal/platform/worktree/... ./internal/state/mutation/... ./internal/ext/plugin/... ./internal/tools/jobs/... ./internal/base/proc/... ./internal/safety/sandbox/... ./internal/base/filelock/... ./internal/contract/eventwire/... ./internal/platform/remote/... ./internal/ext/extension/... ./internal/assembly/boot/... ./internal/session/control/... ./internal/contract/tool/...
+        run: go test -race ./internal/runtime/agent/... ./internal/ext/plugin/... ./internal/tools/jobs/... ./internal/base/proc/... ./internal/safety/sandbox/... ./internal/base/filelock/... ./internal/contract/eventwire/... ./internal/platform/remote/... ./internal/ext/extension/... ./internal/assembly/boot/... ./internal/session/control/... ./internal/contract/tool/...
 
-  # Push-only full suites. internal/frontend/serve and internal/assembly/boot run
-  # hundreds of serial tests and set the wall time of one whole-tree `go test`,
-  # so each is cut by test name into shards that run on their own runners. The
-  # -run / -skip patterns partition the names exactly: every test lands in one
-  # shard. `rest` is every other package. Pull requests keep the focused steps
-  # in the `test` and `race` jobs above.
-  test-windows-shards:
-    if: github.event_name != 'pull_request'
-    name: test (windows-latest, ${{ matrix.shard }})
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { shard: rest }
-          - { shard: serve-1, pkg: ./internal/frontend/serve, flag: -run, filter: '^Test[A-E]' }
-          - { shard: serve-2, pkg: ./internal/frontend/serve, flag: -run, filter: '^Test[F-R]' }
-          - { shard: serve-3, pkg: ./internal/frontend/serve, flag: -skip, filter: '^Test[A-R]' }
-          - { shard: boot-1, pkg: ./internal/assembly/boot, flag: -skip, filter: '^TestEffect([^0-9A-C]|$)' }
-          - { shard: boot-2, pkg: ./internal/assembly/boot, flag: -run, filter: '^TestEffect[D-O]' }
-          - { shard: boot-3, pkg: ./internal/assembly/boot, flag: -run, filter: '^TestEffect([^0-9A-O]|$)' }
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
-
-      - uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7
-        with:
-          go-version-file: go.mod
-          cache: true
-
-      - name: test (shard)
-        timeout-minutes: 40
-        env:
-          # Run the prompt-cache prefix-stability guard (TestCacheHit*) in CI: a
-          # regression there silently tanks the cache hit rate the project is
-          # built around.
-          REASONIX_RELEASE_CACHE_GUARD: "1"
-          # Bound sandbox helper children in Windows tests so a failed OS-level
-          # launch cannot pin the Actions step after Go's package timeout fires.
-          WINDOWS_SANDBOX_WAIT_MS: "20000"
-          SHARD: ${{ matrix.shard }}
-          PKG: ${{ matrix.pkg }}
-          FLAG: ${{ matrix.flag }}
-          FILTER: ${{ matrix.filter }}
-        shell: bash
-        run: |
-          if [ "$SHARD" = rest ]; then
-            mapfile -t pkgs < <(go list ./... | tr -d '\r' | grep -v -E '/internal/(frontend/serve|assembly/boot)$')
-          else
-            pkgs=("$PKG")
-          fi
-          filter=()
-          if [ -n "$FILTER" ]; then filter=("$FLAG" "$FILTER"); fi
-          go test -count=1 -p 4 -timeout=36m -json "${filter[@]}" "${pkgs[@]}" | tee "$RUNNER_TEMP/shard.jsonl" |
-            jq -rj --unbuffered 'select(.Action == "output" and .Test == null) | .Output'
-
-      - name: test (shard) failure detail
-        if: failure()
-        shell: bash
-        run: |
-          f="$RUNNER_TEMP/shard.jsonl"
-          [ -s "$f" ] || exit 0
-          echo "::group::output of failed tests"
-          jq -rn '[inputs | select(.Test != null)] | group_by(.Package + "/" + .Test)
-            | map(select(any(.[]; .Action == "fail")))[]
-            | map(select(.Action == "output") | .Output) | join("")' "$f" || true
-          echo "::endgroup::"
-          echo "slowest tests (seconds, package, name):"
-          jq -rn '[inputs | select(.Test != null and .Action == "pass")]
-            | sort_by(-.Elapsed)[:15][] | "\(.Elapsed)	\(.Package)	\(.Test)"' "$f" || true
-
-  race-shards:
-    if: github.event_name != 'pull_request'
-    name: race (${{ matrix.shard }})
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { shard: rest }
-          - { shard: serve-1, pkg: ./internal/frontend/serve, flag: -run, filter: '^Test[A-E]' }
-          - { shard: serve-2, pkg: ./internal/frontend/serve, flag: -run, filter: '^Test[F-R]' }
-          - { shard: serve-3, pkg: ./internal/frontend/serve, flag: -skip, filter: '^Test[A-R]' }
-          - { shard: boot-1, pkg: ./internal/assembly/boot, flag: -skip, filter: '^TestEffect([^0-9A-C]|$)' }
-          - { shard: boot-2, pkg: ./internal/assembly/boot, flag: -run, filter: '^TestEffect[D-O]' }
-          - { shard: boot-3, pkg: ./internal/assembly/boot, flag: -run, filter: '^TestEffect([^0-9A-O]|$)' }
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
-
-      - uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7
-        with:
-          go-version-file: go.mod
-          cache: true
-
-      - name: Install and verify Linux sandbox backend
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y bubblewrap
-          if sysctl -n kernel.unprivileged_userns_clone >/dev/null 2>&1; then
-            sudo sysctl -w kernel.unprivileged_userns_clone=1
-          fi
-          if sysctl -n kernel.apparmor_restrict_unprivileged_userns >/dev/null 2>&1; then
-            sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
-          fi
-          bwrap --ro-bind / / --dev /dev --proc /proc -- true ||             echo "::warning::bubblewrap is installed but this runner denies user namespaces; unavailable-backend tests will run fail-closed"
-
-      - name: test -race (shard)
-        timeout-minutes: 30
+      - name: test -race (full)
+        if: github.event_name != 'pull_request'
         env:
           REASONIX_RELEASE_CACHE_GUARD: "1"
-          SHARD: ${{ matrix.shard }}
-          PKG: ${{ matrix.pkg }}
-          FLAG: ${{ matrix.flag }}
-          FILTER: ${{ matrix.filter }}
-        run: |
-          if [ "$SHARD" = rest ]; then
-            mapfile -t pkgs < <(go list ./... | grep -v -E '/internal/(frontend/serve|assembly/boot)$')
-          else
-            pkgs=("$PKG")
-          fi
-          filter=()
-          if [ -n "$FILTER" ]; then filter=("$FLAG" "$FILTER"); fi
-          go test -race -timeout=25m "${filter[@]}" "${pkgs[@]}"
+        run: go test -race ./...
 
   # sdk/go is a nested stdlib-only module invisible to root `go test ./...`.
   # Its DTOs are generated from internal/ext/extension/protocol, and the
@@ -1153,7 +515,6 @@ jobs:
         run: |
           go run github.com/rhysd/actionlint/cmd/[email protected] \
             -ignore 'label "windows-11-arm" is unknown' \
-            -ignore 'label "ubuntu-22.04-arm" is unknown' \
             .github/workflows/release-studio.yml \
             .github/workflows/studio-certum-signing-smoke.yml \
             .github/workflows/ci.yml

.github/workflows/codeql.yml

@@ -43,20 +43,20 @@ jobs:
         if: matrix.branch != ''
         run: echo "sha=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1
+        uses: github/codeql-action/init@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.language == 'go' && 'autobuild' || 'none' }}
       - name: Perform CodeQL Analysis
         if: matrix.branch == ''
-        uses: github/codeql-action/analyze@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1
+        uses: github/codeql-action/analyze@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
         with:
           category: "/language:${{ matrix.language }}"
       # Results from a checked-out line are filed under that line's ref, not the
       # default branch the schedule happened to run from.
       - name: Perform CodeQL Analysis (${{ matrix.branch }})
         if: matrix.branch != ''
-        uses: github/codeql-action/analyze@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1
+        uses: github/codeql-action/analyze@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
         with:
           category: "/language:${{ matrix.language }}"
           ref: refs/heads/${{ matrix.branch }}

.github/workflows/e2e-bot.yml

@@ -51,7 +51,7 @@ jobs:
           go-version-file: go.mod
           cache: true
 
-      - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7
         with:
           python-version: '3.12'
 

.github/workflows/pages.yml

@@ -1,32 +0,0 @@
-name: Deploy website
-
-# GitHub requires workflow_dispatch to be registered on the default branch.
-# The production implementation is the same workflow path on website.
-on:
-  workflow_dispatch:
-    inputs:
-      release_version:
-        description: "Optional product release version associated with this publication"
-        required: false
-        default: ""
-        type: string
-      release_request:
-        description: "Optional release workflow correlation ID"
-        required: false
-        default: ""
-        type: string
-      studio_version:
-        description: "Studio version that must be present in the generated changelog"
-        required: false
-        default: ""
-        type: string
-
-permissions: {}
-
-jobs:
-  require-website:
-    runs-on: ubuntu-latest
-    steps:
-      - run: |
-          echo "::error::Deploy the website with --ref website; production is restricted to that branch."
-          exit 1

.github/workflows/pr-author-gate.yml

@@ -1,27 +0,0 @@
-name: PR author gate
-
-# Pull requests are limited to maintainers and the logins in .github/pr-authors.txt.
-# This runs in the base repository's context, checks out the base branch only, and
-# never executes pull-request code; the allowlist it reads is the base branch's.
-on:
-  pull_request_target:
-    types: [opened]
-
-permissions:
-  contents: read
-  pull-requests: write
-
-concurrency:
-  group: pr-author-gate-${{ github.event.pull_request.number }}
-  cancel-in-progress: false
-
-jobs:
-  gate:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
-        with:
-          persist-credentials: false
-      - run: node scripts/pr-author-gate.mjs
-        env:
-          GH_TOKEN: ${{ github.token }}

.github/workflows/release-studio.yml

@@ -175,9 +175,6 @@ jobs:
           - platform: linux/amd64
             runner: ubuntu-22.04
             artifact: studio-build-linux-amd64
-          - platform: linux/arm64
-            runner: ubuntu-22.04-arm
-            artifact: studio-build-linux-arm64
     steps:
       # Real-time scanning inspects every file the job writes, and packaging
       # writes a quarter of a gigabyte twice. The runner is thrown away after
@@ -219,16 +216,7 @@ jobs:
       # not this shell's.
       - name: Install Linux packaging deps
         if: runner.os == 'Linux'
-        run: sudo apt-get update && sudo apt-get install -y fakeroot rpm cpio xvfb xauth policykit-1
-
-      # The fpm electron-builder carries is an x86_64 program, so on an ARM64
-      # runner the .deb and .rpm are built with one installed from RubyGems.
-      - name: Use a native fpm on ARM64 Linux
-        if: runner.os == 'Linux' && runner.arch == 'ARM64'
-        run: |
-          sudo apt-get install -y ruby ruby-dev build-essential
-          sudo gem install --no-document fpm -v 1.16.0
-          echo "USE_SYSTEM_FPM=true" >> "$GITHUB_ENV"
+        run: sudo apt-get update && sudo apt-get install -y fakeroot rpm
 
       # The same Developer ID and notary credentials the desktop line uses: one
       # certificate signs any bundle identifier its team owns, so Studio does not
@@ -372,31 +360,6 @@ jobs:
           pnpm exec electron-builder --prepackaged "../../$app" $arch \
             -c.extraMetadata.version="${version#v}"
 
-      - name: Verify both Linux package formats
-        if: runner.os == 'Linux'
-        shell: bash
-        run: |
-          platform="${{ matrix.platform }}"
-          arch="${platform#linux/}"
-          bash scripts/verify-linux-package.sh "dist/ReasonixStudio-linux-$arch.deb" "dist/ReasonixStudio-linux-$arch.rpm" "$arch"
-
-      - name: Accept the installed Linux package
-        if: runner.os == 'Linux'
-        shell: bash
-        run: |
-          platform="${{ matrix.platform }}"
-          arch="${platform#linux/}"
-          version="${{ needs.resolve.outputs.version }}"
-          bash scripts/linux-install-smoke.sh "dist/ReasonixStudio-linux-$arch.deb" "$arch" "${version#v}"
-
-      - name: Verify the AppImage
-        if: runner.os == 'Linux'
-        shell: bash
-        run: |
-          platform="${{ matrix.platform }}"
-          arch="${platform#linux/}"
-          bash scripts/verify-linux-appimage.sh "dist/ReasonixStudio-linux-$arch.AppImage" "$arch"
-
       # With signing on, this leg only hands the bundle on: the signing jobs
       # run nothing but the signer, and windows-package packages in between.
       - name: Upload the unsigned Windows bundle for signing
@@ -908,31 +871,12 @@ jobs:
           go-version-file: go.mod
           cache: true
 
-      # The page every archive carries beside the executable, built once here
-      # rather than once per target: serve.FindPage looks for
-      # frontend-next/dist next to the binary.
-      - uses: pnpm/action-setup@ea17c68df8912ef543352723c149a84f56e3d413 # v6.1.0
-        with:
-          version: 10
-          run_install: false
-
-      - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7
-        with:
-          node-version: "24"
-          cache: pnpm
-          cache-dependency-path: desktop/frontend-next/pnpm-lock.yaml
-
-      - name: Build the page
-        working-directory: desktop/frontend-next
-        run: pnpm install --frozen-lockfile && pnpm build
-
       # Every target the release line claims to support, from one runner: the
       # CLI is CGO-free, so none of them needs a toolchain of its own.
       - name: Cross-compile and archive
         env:
           VERSION: ${{ needs.resolve.outputs.version }}
           SHA: ${{ needs.resolve.outputs.sha }}
-          PAGE_DIR: desktop/frontend-next/dist
         run: |
           set -euo pipefail
           mkdir -p dist
@@ -944,7 +888,11 @@ jobs:
             CGO_ENABLED=0 GOOS="$os" GOARCH="$arch" go build -trimpath \
               -ldflags "-s -w -X main.version=$VERSION -X main.gitCommit=${SHA:0:12} -X main.buildTimeUTC=$built -X $pkg.linkedVersion=$VERSION -X $pkg.linkedRevision=$SHA" \
               -o "reasonix$ext" ./cmd/reasonix
-            scripts/package-cli-archive.sh "$os" "$arch" "reasonix$ext" "$PAGE_DIR" dist
+            if [ "$os" = windows ]; then
+              zip -qj "dist/reasonix-$os-$arch.zip" "reasonix$ext"
+            else
+              tar czf "dist/reasonix-$os-$arch.tar.gz" "reasonix$ext"
+            fi
             rm -f "reasonix$ext"
           done
           # The digest list the remote verifies against. Resolved on the
@@ -956,7 +904,13 @@ jobs:
       # A release that published the archives without the digest list is worse
       # than one that published neither: the routes resolve SHA256SUMS first.
       - name: Check the set is complete
-        run: python3 scripts/check-cli-archives.py dist
+        run: |
+          set -euo pipefail
+          for want in reasonix-darwin-amd64.tar.gz reasonix-darwin-arm64.tar.gz \
+            reasonix-linux-amd64.tar.gz reasonix-linux-arm64.tar.gz \
+            reasonix-windows-amd64.zip reasonix-windows-arm64.zip SHA256SUMS; do
+            [ -f "dist/$want" ] || { echo "::error::no dist/$want"; exit 1; }
+          done
 
       - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
@@ -1032,11 +986,6 @@ jobs:
           name: studio-build-linux-amd64
           path: staging/studio-build-linux-amd64
 
-      - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
-        with:
-          name: studio-build-linux-arm64
-          path: staging/studio-build-linux-arm64
-
       - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
         if: needs.windows-sign-installer.result == 'success'
         with:
@@ -1119,7 +1068,34 @@ jobs:
           done < <(find staging/studio-* -type f -name 'ReasonixStudio-*' -print0
             find staging/cli-archives -type f -print0)
           ls -la dist
-          bash scripts/verify-studio-artifacts.sh dist
+          # Two Windows artifacts (installer, portable zip) per architecture,
+          # two per macOS architecture (dmg, zip) and the Linux .deb and .rpm. Fewer
+          # means an artifact was lost between jobs, and a partial release is
+          # worse than a failed one.
+          count=$(find dist -type f -name 'ReasonixStudio-*' | wc -l)
+          if [ "$count" -lt 10 ]; then
+            echo "::error::expected 10 artifacts (Windows installer + zip per architecture, macOS dmg + zip per architecture, Linux .deb and .rpm), found $count"
+            exit 1
+          fi
+          # Each platform's update channel, and there is exactly one per
+          # platform: dpkg on Linux, the next installer on Windows, and the
+          # bundle swapped out of the archive on macOS. Missing one degrades the
+          # release silently instead of failing it — it strands that platform on
+          # the version it is running.
+          # Each macOS architecture by name, not darwin-*: a glob passes on
+          # whichever one shipped, and the missing one is a platform left on
+          # the version it is running with nothing saying so.
+          # Each Windows architecture by name for the same reason: a glob passes
+          # on whichever installer shipped.
+          for required in 'ReasonixStudio-linux-*.deb' 'ReasonixStudio-linux-*.rpm' \
+            'ReasonixStudio-windows-amd64-installer.exe' 'ReasonixStudio-windows-arm64-installer.exe' \
+            'ReasonixStudio-windows-amd64.zip' 'ReasonixStudio-windows-arm64.zip' \
+            'ReasonixStudio-darwin-amd64.zip' 'ReasonixStudio-darwin-arm64.zip'; do
+            find dist -type f -name "$required" | grep -q . || {
+              echo "::error::no $required in the release; its packager did not run"
+              exit 1
+            }
+          done
 
       # The same minisign key the desktop line uses, because the public key that
       # verifies it is compiled into the client (update.PublicKey).
@@ -1207,7 +1183,7 @@ jobs:
           fi
           {
             printf '%s\n\n' '---'
-            printf "**macOS** 已用 Developer ID 签名并公证，打开时不需要清除隔离属性。%s**Linux** Debian 系从 \`.deb\` 安装，Fedora、RHEL、openSUSE 等从 \`.rpm\` 安装（\`sudo dnf install ./ReasonixStudio-linux-amd64.rpm\`）。x86_64 用文件名带 amd64 的包，aarch64（统信 UOS、麒麟等）用带 arm64 的包。也提供 \`.AppImage\`（只提供下载，不会自更新；需要 FUSE 2，或用 \`--appimage-extract-and-run\` 启动）。\n\n" "$windows"
+            printf "**macOS** 已用 Developer ID 签名并公证，打开时不需要清除隔离属性。%s**Linux** Debian 系从 \`.deb\` 安装，Fedora、RHEL、openSUSE 等从 \`.rpm\` 安装（\`sudo dnf install ./ReasonixStudio-linux-amd64.rpm\`）。\n\n" "$windows"
             printf "%s\n" "三个平台都能自更新：Linux 的 \`.deb\` 走自己的包（\`.rpm\` 的自更新尚未提供，请手动下载新包），Windows 运行下一个安装器，macOS 替换自身 bundle。"
           } >> "$notes"
           assets=()
@@ -1302,25 +1278,6 @@ jobs:
             --cache-control "public, max-age=300, stale-if-error=86400"
           echo "Studio catalog -> $VERSION"
 
-  website:
-    name: publish the Studio website changelog
-    needs: [resolve, publish]
-    if: github.repository == 'esengine/DeepSeek-Reasonix' && needs.resolve.outputs.candidate != 'true'
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    permissions:
-      contents: read
-      actions: write
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
-        with:
-          ref: ${{ github.workflow_sha }}
-      - name: Deploy and verify the website changelog
-        env:
-          GH_TOKEN: ${{ github.token }}
-          VERSION: ${{ needs.resolve.outputs.version }}
-        run: bash scripts/publish-studio-changelog.sh
-
   # A CLI channel that moves while 1.x still publishes would have two lines
   # writing it, so every CLI job waits for this check. It runs no repository code.
   cli-gate:

.github/workflows/studio.yml

@@ -16,7 +16,7 @@ permissions:
 
 concurrency:
   group: studio-${{ github.ref }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' || github.ref == 'refs/heads/studio' }}
+  cancel-in-progress: true
 
 jobs:
   frontend:
@@ -87,7 +87,7 @@ jobs:
   browser-guards:
     name: browser guards
     runs-on: ubuntu-latest
-    timeout-minutes: 25
+    timeout-minutes: 15
     defaults:
       run:
         working-directory: desktop/frontend-next
@@ -136,153 +136,11 @@ jobs:
           python3 -m http.server 4399 --directory dist-perf >/dev/null 2>&1 &
           for _ in $(seq 30); do curl -sf http://localhost:4399/perf.html >/dev/null && break; sleep 1; done
           node perf/intrinsic.mjs
-          node perf/firstscreen-fonts.mjs
           node perf/contrast.mjs
-          node perf/stickyfold.mjs
-          node perf/crumb.mjs
-          node perf/hoverradius.mjs
-          node perf/jump-ends.mjs
-          node perf/modelrows.mjs
-          node perf/explorersize.mjs
-          node perf/git-panel.mjs
-          node perf/session-move-to.mjs
-          node perf/shell-refused.mjs
-          node perf/external-origin.mjs
-          node perf/rail-search-hold.mjs
-          node perf/rail-toggle-panes.mjs
-          node perf/session-move.mjs
-          node perf/session-ref.mjs
-          node perf/browser-full.mjs
-          node perf/mod-ui.mjs
-          node perf/codeeditor-size.mjs
-          node perf/composer-reflow.mjs
-          node perf/composer-toolbar-row.mjs
-          node perf/action-icons.mjs
-          node perf/rowhit.mjs
-          node perf/prefs-wide-centered.mjs
-          node perf/tab-pip.mjs
-          node perf/syntax-tokens.mjs
-          node perf/tab-close-inside.mjs
-          node perf/context-card-hover.mjs
-          node perf/sessquick.mjs
-          node perf/sessionrows.mjs
-          node perf/session-row-marker.mjs
-          node perf/session-selected-row.mjs
           node perf/wheel.mjs
           node perf/branch-tooltip.mjs
-          node perf/branch-alignment.mjs
-          node perf/branch-menu.mjs
-          node perf/image-preview.mjs
-          node perf/user-images.mjs
-          node perf/toast-anchor.mjs
-          node perf/addfolder-rest.mjs
-          node perf/scroll-jump.mjs
-          node perf/add-project-selects.mjs
-          node perf/project-header.mjs
-          node perf/setup-defer.mjs
-          node perf/narrow.mjs
-          node perf/settings-rows.mjs
-          node perf/narrow-steps.mjs
-          node perf/job-names.mjs
-          node perf/mcp-actions.mjs
-          node perf/web-access.mjs
-          node perf/peers-settings.mjs
-          node perf/output-cap.mjs
-          node perf/tool-output-clip.mjs
-          node perf/agent-run-tab.mjs
-          node perf/changes-cap.mjs
-          node perf/session-menu-fit.mjs
-          node perf/rail-rows-typography.mjs
-          node perf/settings-nav-fit.mjs
-          node perf/rail-rows-align.mjs
-          node perf/progress-tail.mjs
-          node perf/trust-wait.mjs
-          node perf/nest-nodes.mjs
-          node perf/provider-ports.mjs
-          node perf/peer-threads.mjs
-          node perf/text-size.mjs
-          node perf/fs-scale.mjs
-          node perf/composer-feel.mjs
-          node perf/side-panel.mjs
-          node perf/card-shell.mjs
-          node perf/line-cards.mjs
-          node perf/detail-panel.mjs
-          node perf/brand-lockup.mjs
-          node perf/notice-line.mjs
-          node perf/brought-line.mjs
-          node perf/modal-focus.mjs
-          node perf/focus-ring.mjs
-          node perf/narrow-forms.mjs
-          node perf/i18n-rendered.mjs
-          node perf/narrow-rail.mjs
           node perf/selfcheck.mjs branch-tooltip
 
-  # What a hosted page does over the relay, end to end: the production bundle,
-  # the real Studio host and kernel, a real Chromium; only the accounts API and
-  # the relay are stand-ins (tools/relayfake). Event-transport changes are
-  # judged here, because a unit test of one side cannot see the other.
-  relay-harness:
-    name: relay harness
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
-        with:
-          fetch-depth: 0
-
-      - name: Transport changed?
-        id: scope
-        env:
-          BASE_REF: ${{ github.base_ref }}
-        run: |
-          paths="desktop/frontend-next internal/frontend/serve internal/platform/remotecloud internal/platform/account tools/relayfake cmd/reasonix-studio-host"
-          if [ "$GITHUB_EVENT_NAME" = "pull_request" ] &&
-             git diff --quiet "origin/$BASE_REF...HEAD" -- $paths; then
-            echo "run=false" >> "$GITHUB_OUTPUT"
-          else
-            echo "run=true" >> "$GITHUB_OUTPUT"
-          fi
-
-      - if: steps.scope.outputs.run == 'true'
-        uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e # v7
-        with:
-          go-version-file: go.mod
-          cache: true
-
-      - if: steps.scope.outputs.run == 'true'
-        uses: pnpm/action-setup@ea17c68df8912ef543352723c149a84f56e3d413 # v6.1.0
-        with:
-          version: 10
-          run_install: false
-
-      - if: steps.scope.outputs.run == 'true'
-        uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7
-        with:
-          node-version: "24"
-          cache: pnpm
-          cache-dependency-path: desktop/frontend-next/pnpm-lock.yaml
-
-      - if: steps.scope.outputs.run == 'true'
-        name: Build the host, the stand-ins and the page
-        run: |
-          go build -o desktop/frontend-next/relay/bin/studio-host ./cmd/reasonix-studio-host
-          go build -o desktop/frontend-next/relay/bin/relayfake ./tools/relayfake
-          cd desktop/frontend-next
-          pnpm install --frozen-lockfile
-          pnpm exec vite build --outDir dist-relay --emptyOutDir
-          pnpm exec playwright install --with-deps chromium
-
-      - if: steps.scope.outputs.run == 'true'
-        name: Scenarios (hosted page over the relay; local page on a flapping network)
-        working-directory: desktop/frontend-next
-        env:
-          RELAY_HOST_BIN: ${{ github.workspace }}/desktop/frontend-next/relay/bin/studio-host
-          RELAY_FAKE_BIN: ${{ github.workspace }}/desktop/frontend-next/relay/bin/relayfake
-          RELAY_DIST: ${{ github.workspace }}/desktop/frontend-next/dist-relay
-        run: |
-          node relay/live.mjs
-          node relay/storm.mjs
-
   # A pull request with no platform-relevant change (scripts/ci-platform-scope.sh)
   # moves the Windows and macOS legs onto an ubuntu runner with every step
   # skipped, so the check names still report without a scarce runner. A push to
@@ -322,31 +180,6 @@ jobs:
         if: env.RUN_STEPS == 'true'
         run: go test ./...
 
-      - if: env.RUN_STEPS == 'true'
-        uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7
-        with:
-          node-version: "24"
-
-      - name: CUA process and packaging contracts
-        if: env.RUN_STEPS == 'true'
-        timeout-minutes: 2
-        run: node --test --test-name-pattern=CUA electron/test/unit.mjs
-
-      - name: Install Linux native CUA fixture dependencies
-        if: env.RUN_STEPS == 'true' && runner.os == 'Linux'
-        run: sudo apt-get update && sudo apt-get install -y xvfb openbox dbus-x11 libgtk-3-dev at-spi2-core
-
-      - name: Native CUA application acceptance
-        if: env.RUN_STEPS == 'true'
-        timeout-minutes: 6
-        shell: bash
-        run: |
-          if [ "$RUNNER_OS" = Linux ]; then
-            dbus-run-session -- xvfb-run -a sh -c 'openbox >/tmp/reasonix-openbox.log 2>&1 & export NO_AT_BRIDGE=0 GTK_MODULES=gail:atk-bridge; node electron/test/cua-native.mjs'
-          else
-            node electron/test/cua-native.mjs
-          fi
-
       # The host sits in the main module and nothing else builds it, so its
       # dependency closure is checked here: it must stay CGO-free and
       # platform-neutral or the Electron bundle cannot ship it. Cross-compiling
@@ -356,9 +189,7 @@ jobs:
         working-directory: .
         run: |
           for os in windows linux darwin; do
-            for arch in amd64 arm64; do
-              CGO_ENABLED=0 GOOS=$os GOARCH=$arch go build -o /dev/null ./cmd/reasonix-studio-host
-            done
+            CGO_ENABLED=0 GOOS=$os GOARCH=amd64 go build -o /dev/null ./cmd/reasonix-studio-host
           done
 
   # The ARM64 leg queues on a scarcer runner pool, so a pull request runs it
@@ -388,7 +219,7 @@ jobs:
             arm64=false
             platform=$(git diff -z --name-only --no-renames "$BASE_SHA" HEAD | bash scripts/ci-platform-scope.sh)
             if git diff --name-only --no-renames "$BASE_SHA" HEAD |
-              grep -qE '^(desktop/electron/|desktop/packaging/|desktop/cmd/update-helper/|desktop/cmd/studio-manifest/|desktop/go\.(mod|sum)$|cmd/reasonix-studio-host/|internal/platform/(update|appupdate)/|go\.(mod|sum)$|scripts/(linux-install-smoke|verify-linux-package|verify-linux-appimage|verify-studio-artifacts)\.sh$|scripts/(windows-signing-lib|verify-windows-package|verify-windows-authenticode|install-smoke)\.ps1$|\.github/workflows/(studio|release-studio)\.yml$)'; then
+              grep -qE '^(desktop/electron/|desktop/cmd/studio-manifest/|desktop/go\.(mod|sum)$|cmd/reasonix-studio-host/|internal/platform/(update|appupdate)/|go\.(mod|sum)$|scripts/(windows-signing-lib|verify-windows-package|verify-windows-authenticode|install-smoke)\.ps1$|\.github/workflows/(studio|release-studio)\.yml$)'; then
               arm64=true
             fi
           fi
@@ -400,7 +231,7 @@ jobs:
           if [ "$platform" = false ]; then
             legs="$(jq -c 'map(select(.platform == "linux"))' <<<"$legs")"
           elif [ "$arm64" = true ]; then
-            legs="$(jq -c '. + [{"os":"windows-11-arm","arch":"arm64","platform":"windows","ebarch":"arm64"},{"os":"ubuntu-22.04-arm","arch":"arm64","platform":"linux"}]' <<<"$legs")"
+            legs="$(jq -c '. + [{"os":"windows-11-arm","arch":"arm64","platform":"windows","ebarch":"arm64"}]' <<<"$legs")"
           else
             legs="$(jq -c . <<<"$legs")"
           fi
@@ -450,16 +281,7 @@ jobs:
       # to rpmbuild for the .rpm.
       - name: Install Linux packaging deps
         if: runner.os == 'Linux'
-        run: sudo apt-get update && sudo apt-get install -y fakeroot rpm cpio xvfb xauth policykit-1
-
-      # The fpm electron-builder carries is an x86_64 program, so on an ARM64
-      # runner the .deb and .rpm are built with one installed from RubyGems.
-      - name: Use a native fpm on ARM64 Linux
-        if: runner.os == 'Linux' && runner.arch == 'ARM64'
-        run: |
-          sudo apt-get install -y ruby ruby-dev build-essential
-          sudo gem install --no-document fpm -v 1.16.0
-          echo "USE_SYSTEM_FPM=true" >> "$GITHUB_ENV"
+        run: sudo apt-get update && sudo apt-get install -y fakeroot rpm
 
       - name: Build the SPA
         working-directory: desktop/frontend-next
@@ -472,8 +294,7 @@ jobs:
         working-directory: desktop/electron
         env:
           REASONIX_GOARCH: ${{ matrix.platform == 'windows' && matrix.arch || '' }}
-          REASONIX_VERSION: v0.0.0-ci
-        run: pnpm install --frozen-lockfile && pnpm test && pnpm run build:host
+        run: pnpm install --frozen-lockfile && pnpm run build:host
 
       # The .deb's absolute-path payload. A no-op off Linux, so it is not
       # guarded here: the one place it must not be forgotten is the one place
@@ -489,7 +310,7 @@ jobs:
         env:
           CSC_IDENTITY_AUTO_DISCOVERY: "false"
           ELECTRON_BUILDER_7Z_FILTER: ${{ matrix.platform == 'windows' && matrix.arch == 'arm64' && 'BCJ' || '' }}
-        run: pnpm run build:dist ${{ matrix.ebarch && format('--{0}', matrix.ebarch) || '' }} -c.extraMetadata.version=0.0.0-ci
+        run: pnpm run build:dist ${{ matrix.ebarch && format('--{0}', matrix.ebarch) || '' }}
 
       # The release vocabulary is GOARCH. electron-builder's own is not, and the
       # rename that reconciles them runs here rather than in the manifest.
@@ -624,17 +445,82 @@ jobs:
           echo "page:   ${page:-<missing>}"
           test -n "$host" -a -n "$page"
 
-      - name: Linux packages carry their declared architecture and update payload
+      # Read off the package rather than off the config that describes it. Both
+      # of these went wrong the same way once: electron-builder names a package
+      # after package.json unless told, and fpm records the owner it finds on
+      # disk. Either one leaves a Studio that cannot update itself on Linux and
+      # says nothing about it until a user asks.
+      - name: The .deb is Studio's own package and carries what updates it
         if: runner.os == 'Linux'
-        run: bash scripts/verify-linux-package.sh "dist/ReasonixStudio-linux-${{ matrix.arch }}.deb" "dist/ReasonixStudio-linux-${{ matrix.arch }}.rpm" "${{ matrix.arch }}"
+        run: |
+          deb=$(ls dist/ReasonixStudio-linux-*.deb)
+          name=$(dpkg-deb -f "$deb" Package)
+          if [ "$name" != "reasonix-studio" ]; then
+            echo "::error::the package is $name; dpkg holds that beside the installed reasonix-studio instead of upgrading it, and update.StudioLine asks for it by name"
+            exit 1
+          fi
+          # The helper in the package accepts one package name, compiled in. It has
+          # to be the one the package carries, or every in-app update is refused
+          # as a different package after the download and signature succeed.
+          dpkg-deb --fsys-tarfile "$deb" | tar -xO ./usr/lib/reasonix-studio/reasonix-studio-update-helper > "$RUNNER_TEMP/update-helper"
+          chmod +x "$RUNNER_TEMP/update-helper"
+          accepts=$("$RUNNER_TEMP/update-helper" package)
+          if [ "$accepts" != "$name" ]; then
+            echo "::error::the update helper in the package accepts $accepts but the package is $name"
+            exit 1
+          fi
+          dpkg-deb -c "$deb" > contents.txt
+          # The path is the polkit action's exec.path annotation, so it is the
+          # only one authorization is granted for; root because polkit will not
+          # run a helper the invoking user could have written. Either spelling
+          # of root: dpkg-deb prints the numeric ids it cannot map, and which
+          # one it prints is a property of the machine reading the package
+          # rather than of the package.
+          if ! grep -qE '^-rwxr-xr-x (root/root|0/0) +[0-9]+ .* \./usr/lib/reasonix-studio/reasonix-studio-update-helper$' contents.txt; then
+            echo "::error::no root-owned executable update helper at the path the polkit action names"
+            grep reasonix-studio-update-helper contents.txt || echo "(not in the package at all)"
+            exit 1
+          fi
+          if ! grep -q './usr/share/polkit-1/actions/io.reasonix.studio.update.policy$' contents.txt; then
+            echo "::error::the polkit action is not in the package, so pkexec has nothing to authorize against"
+            exit 1
+          fi
 
-      - name: The Linux package installs, runs, reinstalls and uninstalls
+      # The .rpm is read back for the same two properties as the .deb: it is the
+      # package update.StudioLine names, and the helper pkexec runs as root is
+      # owned by root and writable by no one else, or any local user could
+      # replace it.
+      - name: The .rpm is Studio's own package and carries what updates it
         if: runner.os == 'Linux'
-        run: bash scripts/linux-install-smoke.sh "dist/ReasonixStudio-linux-${{ matrix.arch }}.deb" "${{ matrix.arch }}" 0.0.0-ci
+        run: |
+          rpm=$(ls dist/ReasonixStudio-linux-*.rpm)
+          name=$(rpm -qp --qf '%{NAME}' "$rpm")
+          if [ "$name" != "reasonix-studio" ]; then
+            echo "::error::the package is $name; rpm holds that beside the installed reasonix-studio instead of upgrading it"
+            exit 1
+          fi
+          rpm -qp --qf '[%{FILEMODES:perms} %{FILEUSERNAME} %{FILEGROUPNAME} %{FILENAMES}\n]' "$rpm" > contents.txt
+          if ! grep -qxE -- '-rwxr-xr-x root root /usr/lib/reasonix-studio/reasonix-studio-update-helper' contents.txt; then
+            echo "::error::no root-owned, executable, not-writable update helper at the path the polkit action names"
+            grep reasonix-studio-update-helper contents.txt || echo "(not in the package at all)"
+            exit 1
+          fi
+          if ! grep -qE -- '^-r[w-][x-]r-[x-]r-[x-] root root /usr/share/polkit-1/actions/io.reasonix.studio.update.policy$' contents.txt; then
+            echo "::error::the polkit action is missing, or is not a root-owned file no one else can write"
+            grep polkit contents.txt || echo "(not in the package at all)"
+            exit 1
+          fi
 
-      - name: The AppImage carries its architecture, the kernel and the page
+      # The Electron shell sets the package's glibc floor; a Go binary linked
+      # with cgo would raise it to the runner's own.
+      - name: The .deb's Go binaries are statically linked
         if: runner.os == 'Linux'
-        run: bash scripts/verify-linux-appimage.sh "dist/ReasonixStudio-linux-${{ matrix.arch }}.AppImage" "${{ matrix.arch }}"
+        run: |
+          deb=$(ls dist/ReasonixStudio-linux-*.deb)
+          dpkg-deb -x "$deb" "$RUNNER_TEMP/deb"
+          host=$(find "$RUNNER_TEMP/deb" -type f -path '*/resources/bin/reasonix-studio-host')
+          test -n "$host"
+          node desktop/electron/packaging/elf.js "$host" "$RUNNER_TEMP/deb/usr/lib/reasonix-studio/reasonix-studio-update-helper"
 
       # Recorded, not asserted: the real bundle layout, so later work argues
       # from what electron-builder produced rather than from its documentation.

.github/workflows/withdraw-studio-version.yml

@@ -1,84 +0,0 @@
-name: Withdraw a Studio version
-
-# Pulls a published Studio release out of the update catalog (or puts it back),
-# so installs stop being offered it without waiting for a new release. Only the
-# catalog changes: the release's files stay where they are, and a withdrawn
-# release can be restored with the same run.
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: "Version to withdraw or restore, for example 2.36.0"
-        required: true
-        type: string
-      reason:
-        description: "Why it is withdrawn (shown to users on that version); ignored when restoring"
-        required: false
-        type: string
-      restore:
-        description: "Put a withdrawn version back instead of withdrawing it"
-        required: false
-        type: boolean
-        default: false
-
-concurrency:
-  group: studio-catalog
-  cancel-in-progress: false
-
-jobs:
-  withdraw:
-    name: ${{ inputs.restore && 'restore' || 'withdraw' }} ${{ inputs.version }}
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    environment: studio-release
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
-        with:
-          ref: studio
-          persist-credentials: false
-
-      - name: Update the Studio catalog
-        env:
-          VERSION: ${{ inputs.version }}
-          REASON: ${{ inputs.reason }}
-          RESTORE: ${{ inputs.restore }}
-          R2_BUCKET: ${{ secrets.R2_BUCKET }}
-          HAS_R2: ${{ secrets.R2_ACCESS_KEY_ID != '' && secrets.R2_SECRET_ACCESS_KEY != '' && secrets.R2_ACCOUNT_ID != '' && secrets.R2_BUCKET != '' }}
-        run: |
-          if [ "$HAS_R2" != "true" ]; then
-            echo "::error::R2 credentials are not configured, so the catalog cannot be changed"
-            exit 1
-          fi
-          if ! [[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.]+)?$ ]]; then
-            echo "::error::version must look like 2.36.0"
-            exit 1
-          fi
-          aws configure set aws_access_key_id "${{ secrets.R2_ACCESS_KEY_ID }}"
-          aws configure set aws_secret_access_key "${{ secrets.R2_SECRET_ACCESS_KEY }}"
-          aws configure set default.region auto
-          endpoint="https://${{ secrets.R2_ACCOUNT_ID }}.r2.cloudflarestorage.com"
-          at="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-          current=/tmp/studio-versions-current.json
-          next=/tmp/studio-versions-next.json
-          aws s3 cp "s3://${R2_BUCKET}/studio/versions.json" "$current" --endpoint-url "$endpoint"
-          if [ "$RESTORE" = "true" ]; then
-            bash scripts/withdraw-version.sh "$current" --restore "$VERSION" "$at" > "$next"
-            jq -e --arg v "$VERSION" '.versions | map(select((.version | ltrimstr("v")) == $v)) | length == 1' "$next" >/dev/null
-          else
-            bash scripts/withdraw-version.sh "$current" "$VERSION" "$REASON" "$at" > "$next"
-            jq -e --arg v "$VERSION" '(.versions | map(select((.version | ltrimstr("v")) == $v)) | length == 0) and (.withdrawn | map(select((.version | ltrimstr("v")) == $v)) | length == 1)' "$next" >/dev/null
-          fi
-          aws s3 cp "$next" "s3://${R2_BUCKET}/studio/versions.json" \
-            --endpoint-url "$endpoint" \
-            --content-type "application/json; charset=utf-8" \
-            --cache-control "public, max-age=300, stale-if-error=86400"
-          echo "Studio catalog updated for $VERSION (restore=$RESTORE)"
-
-      - name: Keep the GitHub release off the latest slot
-        if: ${{ !inputs.restore }}
-        env:
-          GH_TOKEN: ${{ github.token }}
-          VERSION: ${{ inputs.version }}
-        run: gh release edit "studio-v${VERSION}" --prerelease --latest=false --repo "$GITHUB_REPOSITORY"

.gitignore

@@ -95,4 +95,3 @@ scripts/official-theme-art/__pycache__/
 # running, which on Windows is every rebuild while Studio is open.
 *.exe
 *.exe~
-/relayfake

CONTRIBUTING.md

@@ -117,22 +117,6 @@ go test ./internal/runtime/agent/ -v            # verbose, one package
 go test ./internal/tools/builtin/ -run TestGrep  # one test
 ```
 
-`testenv.IsolateUserState` installs a disposable user home and config-edit lock
-scope. Default-path tests can clear `REASONIX_HOME` without losing the test
-registry, while explicitly isolated Reasonix homes retain their own locks.
-
-`REASONIX_TEST_HOME` carries the scope to helper subprocesses. A helper that
-skips the isolation guard must install the inherited home with
-`testscope.InstallHome` before running tests.
-
-The environment variable alone cannot activate a test scope. Production
-executables still use the OS account's home for shared config locks.
-
-The guard removes its scratch home on normal completion. Scratch homes are
-created under the original home, so an interrupted run can still leave
-`.reasonix-test-home-*` directories; this is separate from persistent
-config-edit locks in the real `.reasonix/locks` directory.
-
 ### Code style
 
 - `gofmt` is enforced by CI — format before committing

Makefile

@@ -9,7 +9,7 @@ GOEXE := $(shell go env GOEXE)
 # One pin for the Makefile and the CI lint job; see .github/workflows/ci.yml.
 GOLANGCI_VERSION := $(shell cat .golangci-version)
 
-.PHONY: build vet fmt lint lint-go lint-install lint-cross lint-update coverage-gate coverage-gate-update pricecheck acp-conformance check test studio-test sdk-test sdk-test-race hooks cross clean studio
+.PHONY: build vet fmt lint lint-go lint-install lint-cross lint-update coverage-gate coverage-gate-update pricecheck check test studio-test sdk-test sdk-test-race hooks cross clean studio
 
 build:
 	CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o bin/reasonix$(GOEXE) ./cmd/reasonix
@@ -87,13 +87,6 @@ lint-cross:
 test: studio-test sdk-test
 	go test ./...
 
-# Drives `reasonix acp` with the official ACP TypeScript SDK and holds every
-# message it writes to the schema that SDK ships. Needs node and network for
-# `npm ci`, which runs without install scripts against a lockfile.
-acp-conformance: build
-	cd tools/acp-conformance && npm ci --ignore-scripts --no-audit --no-fund
-	cd tools/acp-conformance && REASONIX_BIN=$(CURDIR)/bin/reasonix$(GOEXE) npm test
-
 # The shell is a nested module, so the root `test` target never reaches it.
 studio-test:
 	cd desktop && go test ./...

README.md

@@ -59,7 +59,7 @@
 
 ## ❤️Sponsor
 
-<table><tr><td width="180" align="center" valign="middle"><a href="https://www.rightapi.ai/register?aff=e083bf73" target="_blank" rel="sponsored noopener noreferrer"><img src="./.github/sponsor/rightcode.png" alt="Right Code" width="64"></a></td><td valign="middle">Thanks to Right Code for sponsoring this project! Right Code reliably provides routing services for models such as Claude Code, Codex, and Gemini, with both pay-as-you-go and monthly subscription billing options available. Invoices are available upon top-up, and enterprise and team users can receive dedicated one-on-one support. Register via <a href="https://www.rightapi.ai/register?aff=e083bf73" target="_blank" rel="sponsored noopener noreferrer">this link</a>.</td></tr><tr><td width="180" align="center" valign="middle"><a href="https://www.packyapi.ai/register?aff=rIbQ" target="_blank" rel="sponsored noopener noreferrer"><picture><source media="(prefers-color-scheme: dark)" srcset="./.github/sponsor/packycode-dark.svg"><img src="./.github/sponsor/packycode-light.svg" alt="PackyCode" width="80"></picture></a></td><td valign="middle">Thanks to PackyCode for sponsoring this project! Access leading AI models through PackyCode with one API endpoint and one API key, with automatic failover and dedicated high-speed routes for Codex and Claude Code. Register via <a href="https://www.packyapi.ai/register?aff=rIbQ" target="_blank" rel="sponsored noopener noreferrer">this link</a>.</td></tr></table>
+<table><tr><td width="180" align="center" valign="middle"><a href="https://www.rightapi.ai/register?aff=e083bf73" target="_blank" rel="sponsored noopener noreferrer"><img src="./.github/sponsor/rightcode.png" alt="Right Code" width="64"></a></td><td valign="middle">Thanks to Right Code for sponsoring this project! Right Code reliably provides routing services for models such as Claude Code, Codex, and Gemini, with both pay-as-you-go and monthly subscription billing options available. Invoices are available upon top-up, and enterprise and team users can receive dedicated one-on-one support.</td></tr><tr><td width="180" align="center" valign="middle"><a href="https://www.packyapi.ai/register?aff=rIbQ" target="_blank" rel="sponsored noopener noreferrer"><picture><source media="(prefers-color-scheme: dark)" srcset="./.github/sponsor/packycode-dark.svg"><img src="./.github/sponsor/packycode-light.svg" alt="PackyCode" width="80"></picture></a></td><td valign="middle">Thanks to PackyCode for sponsoring this project! Access leading AI models through PackyCode with one API endpoint and one API key, with automatic failover and dedicated high-speed routes for Codex and Claude Code.</td></tr></table>
 
 ## What it is
 
@@ -93,16 +93,6 @@ Prefer a terminal? Download the `reasonix` command-line tool, run `reasonix setu
 
 All four are the same program underneath. What follows is for advanced users and contributors.
 
-## Use it from DeepSeek Harness
-
-DeepSeek Harness (`dsh`) can hand a task to Reasonix as a subagent over ACP. This repository publishes a plugin index for it:
-
-1. Run `reasonix setup` on the machine that runs `dsh`. In the DSH Web UI turn on Custom plugin markets (Plugins, More) and add this index in the Discover tab: `https://raw.githubusercontent.com/esengine/DeepSeek-Reasonix/studio/integrations/dsh-plugin/market-index.json`
-2. Install "Reasonix subagent" from it.
-3. Open the plugin's page and turn its switch on. While it is off the model has no `reasonix` tool and may run `reasonix -p` in its own shell, which looks like a delegation and is not one.
-
-Setup details, the permission policy and limits are in [Using Reasonix from DeepSeek Harness](./docs/DSH.md).
-
 ## Versions
 
 Reasonix ships on two lines. See the [version roadmap announcement](https://github.com/esengine/DeepSeek-Reasonix/discussions/10748) for the reasoning behind the split.
@@ -161,7 +151,7 @@ pre-releases):
 | --- | --- | --- |
 | macOS | `.dmg` or `.zip` | Apple Silicon (`arm64`) / Intel (`amd64`) |
 | Windows | Installer `-installer.exe` or portable `.zip` | x64 |
-| Linux | `.deb`, `.rpm`, or `.AppImage` (download only) | x64 (`amd64`) / ARM64 (`arm64`, aarch64) |
+| Linux | `.deb` | x64 |
 
 Every package ships with a `.minisig` signature, and the release carries
 `SHA256SUMS`. Once installed, Studio updates itself in place.
@@ -169,19 +159,6 @@ Every package ships with a `.minisig` signature, and the release carries
 The same release also carries the 2.x `reasonix` CLI as archives for
 `darwin|linux|windows × amd64|arm64`.
 
-The Android build ships on that release as `ReasonixMobile-<version>.apk`
-(`arm64`, Android 8.0 or newer). The kernel and the page run on the phone, and
-the agent reaches your servers over SSH; pairing with a computer is done by
-scanning the code it shows.
-
-The APK is signed with the Android release key rather than minisign, so it
-carries a `.sha256` and no `.minisig`.
-
-When that key is absent the build is named
-`ReasonixMobile-<version>-unsigned.apk`. Android refuses to install an unsigned
-package, so those builds stay a workflow artifact for whoever wants to sign one,
-and the release carries no APK at all.
-
 ### Reasonix 1.x (stable)
 
 The 1.x CLI installs through npm on any supported platform, or Homebrew on
@@ -263,14 +240,12 @@ For advanced CLI usage and configuration, see the **[CLI reference](./docs/CLI.m
 ## Documentation
 
 - **Getting started:** [Guide](./docs/GUIDE.md) · [CLI reference](./docs/CLI.md) ·
-  [Configuration paths](./docs/CONFIG_PATHS.md) · [ACP editor integration](./docs/ACP.md) ·
-  [Use from DeepSeek Harness](./docs/DSH.md)
+  [Configuration paths](./docs/CONFIG_PATHS.md) · [ACP editor integration](./docs/ACP.md)
 - **Features & troubleshooting:** [Subagent profiles](./docs/SUBAGENT_PROFILES.md) ·
   [Context Engine v2](./docs/SESSION_MEMORY_RETRIEVAL.md) ·
   [Capability diagnostics](./docs/CAPABILITY_DIAGNOSTICS.md) ·
   [Recovery and updates](./docs/RECOVERY.md) ·
   [Checkpoints & rewind](./docs/CHECKPOINTS.md)
-- **Agent presets:** [Session Agent compositions](./docs/AGENT_COMPOSITIONS.md)
 - **Engineering & migration:** [Spec](./docs/SPEC.md) ·
   [Task contracts & pause policy](./docs/TASK_CONTRACT.md) ·
   [Tool contract](./docs/TOOL_CONTRACT.md) · [Moving from 1.x to 2.x](./docs/MIGRATING.md) ·
@@ -301,11 +276,11 @@ A small list of folks whose work has shaped Reasonix the most — the current to
 <!-- reasonix-top-contributors:start -->
 | Contributor | Contributor | Contributor | Contributor |
 | --- | --- | --- | --- |
-| [**SivanCola**](https://github.com/SivanCola) | [**KHG420**](https://github.com/KHG420) | [**ttmouse**](https://github.com/ttmouse) | [**chuiwenwei**](https://github.com/chuiwenwei) |
-| [**lifu963**](https://github.com/lifu963) | [**XTLine**](https://github.com/XTLine) | [**HUQIANTAO**](https://github.com/HUQIANTAO) | [**xxoingr**](https://github.com/xxoingr) |
-| [**Harbor404**](https://github.com/Harbor404) | [**GTC2080**](https://github.com/GTC2080) | [**mchenziyi**](https://github.com/mchenziyi) | [**Li-Charles-One**](https://github.com/Li-Charles-One) |
-| [**light-front-theory**](https://github.com/light-front-theory) | [**imcreazy**](https://github.com/imcreazy) | [**eghrhegpe**](https://github.com/eghrhegpe) | [**noreply**](https://github.com/noreply) |
-| [**par73e**](https://github.com/par73e) | [**Bernardxu123**](https://github.com/Bernardxu123) | [**lancy69**](https://github.com/lancy69) | [**Guan0923**](https://github.com/Guan0923) |
+| [**SivanCola**](https://github.com/SivanCola) | [**KHG420**](https://github.com/KHG420) | [**ttmouse**](https://github.com/ttmouse) | [**lifu963**](https://github.com/lifu963) |
+| [**HUQIANTAO**](https://github.com/HUQIANTAO) | [**Harbor404**](https://github.com/Harbor404) | [**GTC2080**](https://github.com/GTC2080) | [**mchenziyi**](https://github.com/mchenziyi) |
+| [**Li-Charles-One**](https://github.com/Li-Charles-One) | [**light-front-theory**](https://github.com/light-front-theory) | [**eghrhegpe**](https://github.com/eghrhegpe) | [**Bernardxu123**](https://github.com/Bernardxu123) |
+| [**HaoyueQin**](https://github.com/HaoyueQin) | [**chuiwenwei**](https://github.com/chuiwenwei) | [**BuGlessRB**](https://github.com/BuGlessRB) | [**CVEngineer66**](https://github.com/CVEngineer66) |
+| [**JesonChou**](https://github.com/JesonChou) | [**lanshi17**](https://github.com/lanshi17) | [**par73e**](https://github.com/par73e) | [**SuMuxi66**](https://github.com/SuMuxi66) |
 <!-- reasonix-top-contributors:end -->
 
 Special thanks to [**Bernardxu123**](https://github.com/Bernardxu123) for designing the project logo and intro video.

README.zh-CN.md

@@ -57,7 +57,7 @@
 
 ## ❤️赞助商
 
-<table><tr><td width="180" align="center" valign="middle"><a href="https://www.rightapi.ai/register?aff=e083bf73" target="_blank" rel="sponsored noopener noreferrer"><img src="./.github/sponsor/rightcode.png" alt="Right Code" width="64"></a></td><td valign="middle">感谢 Right Code 赞助了本项目！Right Code 稳定提供 Claude Code、Codex、Gemini 等模型的中转服务，并可选按量、包月两种计费模式。充值即可开票，企业、团队用户一对一对接。通过<a href="https://www.rightapi.ai/register?aff=e083bf73" target="_blank" rel="sponsored noopener noreferrer">此链接</a>注册。</td></tr><tr><td width="180" align="center" valign="middle"><a href="https://www.packyapi.ai/register?aff=rIbQ" target="_blank" rel="sponsored noopener noreferrer"><picture><source media="(prefers-color-scheme: dark)" srcset="./.github/sponsor/packycode-dark.svg"><img src="./.github/sponsor/packycode-light.svg" alt="PackyCode" width="80"></picture></a></td><td valign="middle">感谢 PackyCode 赞助了本项目！PackyCode 是一家稳定、高效的 API 中转服务商，统一域名、统一密钥、智能容灾切换。通过<a href="https://www.packyapi.ai/register?aff=rIbQ" target="_blank" rel="sponsored noopener noreferrer">此链接</a>注册。</td></tr></table>
+<table><tr><td width="180" align="center" valign="middle"><a href="https://www.rightapi.ai/register?aff=e083bf73" target="_blank" rel="sponsored noopener noreferrer"><img src="./.github/sponsor/rightcode.png" alt="Right Code" width="64"></a></td><td valign="middle">感谢 Right Code 赞助了本项目！Right Code 稳定提供 Claude Code、Codex、Gemini 等模型的中转服务，并可选按量、包月两种计费模式。充值即可开票，企业、团队用户一对一对接。</td></tr><tr><td width="180" align="center" valign="middle"><a href="https://www.packyapi.ai/register?aff=rIbQ" target="_blank" rel="sponsored noopener noreferrer"><picture><source media="(prefers-color-scheme: dark)" srcset="./.github/sponsor/packycode-dark.svg"><img src="./.github/sponsor/packycode-light.svg" alt="PackyCode" width="80"></picture></a></td><td valign="middle">感谢 PackyCode 赞助了本项目！PackyCode 是一家稳定、高效的 API 中转服务商，统一域名、统一密钥、智能容灾切换。</td></tr></table>
 
 ## 它是什么
 
@@ -91,16 +91,6 @@ Reasonix 是一个开源的 AI 编程助手。程序跑在你的电脑上；AI
 
 四种用法背后是同一套程序。下面的内容写给进阶用户和贡献者。
 
-## 在 DeepSeek Harness 里使用
-
-DeepSeek Harness（`dsh`）可以通过 ACP 把任务交给 Reasonix 作为子智能体去做。本仓库为此发布了一个插件索引：
-
-1. 在运行 `dsh` 的机器上先运行 `reasonix setup`。在 DSH 网页界面打开“自定义插件市场”（插件，更多），再到 Discover 页添加这个索引：`https://raw.githubusercontent.com/esengine/DeepSeek-Reasonix/studio/integrations/dsh-plugin/market-index.json`
-2. 从中安装“Reasonix subagent”。
-3. 打开这个插件的页面，把它的开关打开。关着的时候模型没有 `reasonix` 工具，可能改在自己的 shell 里直接运行 `reasonix -p`，看起来像委派，其实不是。
-
-配置细节、权限策略和限制见 [在 DeepSeek Harness 中使用 Reasonix](./docs/DSH.md)。
-
 ## 版本
 
 Reasonix 分为两条版本线，调整的原因见[版本路线公告](https://github.com/esengine/DeepSeek-Reasonix/discussions/10748)。
@@ -149,22 +139,13 @@ Reasonix 分为两条版本线，调整的原因见[版本路线公告](https://
 | --- | --- | --- |
 | macOS | `.dmg` 或 `.zip` | Apple Silicon（`arm64`）/ Intel（`amd64`） |
 | Windows | 安装器 `-installer.exe` 或便携 `.zip` | x64 |
-| Linux | `.deb`、`.rpm` 或 `.AppImage`（只提供下载） | x64（`amd64`）/ ARM64（`arm64`，aarch64） |
+| Linux | `.deb` | x64 |
 
 每个安装包都附带 `.minisig` 签名，发布页另有 `SHA256SUMS`。安装后 Studio 会在
 应用内自行更新。
 
 同一个发布页也提供 2.x 的 `reasonix` CLI 归档（`darwin|linux|windows × amd64|arm64`）。
 
-安卓版在同一个发布页上，文件名是 `ReasonixMobile-<版本>.apk`（`arm64`，Android 8.0 及以上）。
-
-这个 APK 用 Android 发布密钥签名，不走 minisign，因此只有一个 `.sha256`，没有 `.minisig`。
-
-该密钥缺失时产物名为 `ReasonixMobile-<版本>-unsigned.apk`。Android 不接受未签名的包，
-这类构建只留作 workflow 产物供自行签名，发布页上不会挂 APK。
-
-内核与界面都跑在手机上，Agent 通过 SSH 连接你自己的服务器；与电脑配对时扫它显示的二维码。
-
 ### Reasonix 1.x（稳定版）
 
 1.x CLI 在任意支持的平台上都可以通过 npm 安装，macOS 也可以使用 Homebrew：
@@ -240,13 +221,12 @@ CLI 进阶用法和详细配置见 **[CLI 命令参考](./docs/CLI.zh-CN.md)**
 
 - **开始使用：** [指南](./docs/GUIDE.zh-CN.md) ·
   [CLI 命令参考](./docs/CLI.zh-CN.md) · [配置路径](./docs/CONFIG_PATHS.md) ·
-  [ACP 编辑器接入](./docs/ACP.md) · [在 DeepSeek Harness 中使用](./docs/DSH.md)
+  [ACP 编辑器接入](./docs/ACP.md)
 - **功能与排障：** [子智能体 Profile](./docs/SUBAGENT_PROFILES.md) ·
   [Context Engine v2](./docs/SESSION_MEMORY_RETRIEVAL.md) ·
   [能力诊断](./docs/CAPABILITY_DIAGNOSTICS.md) ·
   [恢复与安全模式](./docs/RECOVERY.md) ·
   [Checkpoints 与 rewind](./docs/CHECKPOINTS.md)
-- **Agent 预设：** [会话级组合](./docs/AGENT_COMPOSITIONS.zh.md)
 - **工程与迁移：** [规格](./docs/SPEC.md) ·
   [任务合约与暂停策略](./docs/TASK_CONTRACT.md) ·
   [工具合约](./docs/TOOL_CONTRACT.md) ·
@@ -278,11 +258,11 @@ CLI 进阶用法和详细配置见 **[CLI 命令参考](./docs/CLI.zh-CN.md)**
 <!-- reasonix-top-contributors:start -->
 | Contributor | Contributor | Contributor | Contributor |
 | --- | --- | --- | --- |
-| [**SivanCola**](https://github.com/SivanCola) | [**KHG420**](https://github.com/KHG420) | [**ttmouse**](https://github.com/ttmouse) | [**chuiwenwei**](https://github.com/chuiwenwei) |
-| [**lifu963**](https://github.com/lifu963) | [**XTLine**](https://github.com/XTLine) | [**HUQIANTAO**](https://github.com/HUQIANTAO) | [**xxoingr**](https://github.com/xxoingr) |
-| [**Harbor404**](https://github.com/Harbor404) | [**GTC2080**](https://github.com/GTC2080) | [**mchenziyi**](https://github.com/mchenziyi) | [**Li-Charles-One**](https://github.com/Li-Charles-One) |
-| [**light-front-theory**](https://github.com/light-front-theory) | [**imcreazy**](https://github.com/imcreazy) | [**eghrhegpe**](https://github.com/eghrhegpe) | [**noreply**](https://github.com/noreply) |
-| [**par73e**](https://github.com/par73e) | [**Bernardxu123**](https://github.com/Bernardxu123) | [**lancy69**](https://github.com/lancy69) | [**Guan0923**](https://github.com/Guan0923) |
+| [**SivanCola**](https://github.com/SivanCola) | [**KHG420**](https://github.com/KHG420) | [**ttmouse**](https://github.com/ttmouse) | [**lifu963**](https://github.com/lifu963) |
+| [**HUQIANTAO**](https://github.com/HUQIANTAO) | [**Harbor404**](https://github.com/Harbor404) | [**GTC2080**](https://github.com/GTC2080) | [**mchenziyi**](https://github.com/mchenziyi) |
+| [**Li-Charles-One**](https://github.com/Li-Charles-One) | [**light-front-theory**](https://github.com/light-front-theory) | [**eghrhegpe**](https://github.com/eghrhegpe) | [**Bernardxu123**](https://github.com/Bernardxu123) |
+| [**HaoyueQin**](https://github.com/HaoyueQin) | [**chuiwenwei**](https://github.com/chuiwenwei) | [**BuGlessRB**](https://github.com/BuGlessRB) | [**CVEngineer66**](https://github.com/CVEngineer66) |
+| [**JesonChou**](https://github.com/JesonChou) | [**lanshi17**](https://github.com/lanshi17) | [**par73e**](https://github.com/par73e) | [**SuMuxi66**](https://github.com/SuMuxi66) |
 <!-- reasonix-top-contributors:end -->
 
 特别感谢 [**Bernardxu123**](https://github.com/Bernardxu123) 设计的项目 logo和开场视频。

REASONIX.md

@@ -373,10 +373,6 @@ out of how a path is spelled, which cannot tell `internal/auth` from
 - sensitive: internal/safety/egress/**
 - sensitive: internal/platform/browser/**
 - sensitive: internal/platform/computer/**
-- sensitive: internal/platform/gitpush/**
-- sensitive: internal/session/control/git_push.go
-- sensitive: internal/frontend/serve/git_push.go
-- sensitive: internal/frontend/serve/host_routes.go
 
 One declaration, two effects: the same list is also the coverage gate's subject.
 `make coverage-gate` holds each path to the coverage it already has, because
@@ -413,13 +409,8 @@ moving a number here must not move the promise.
 - Symlinks are recorded by `Lstat`, so a write through one lands outside what
   the walk compares. Confining the resolved target is the sandbox's job.
 - `internal/safety/sandbox` confines writes to the workspace, configured extras, temp
-  and toolchain caches on macOS and Linux.
-- On Windows a user-enabled write-restricted token bounds the *creation* of files
-  (create, append, overwrite, `mkdir`, HKCU writes, global git config, writes through links).
-- There, deleting or renaming away an existing file is not bounded, and with the
-  setting off nothing the host enforces bounds `Writable`.
-- The caches a command may write can be poisoned for the user's later unsandboxed
-  builds, on every platform.
+  and toolchain caches — on macOS and Linux. Windows has no OS-level bash
+  sandbox, so there nothing the host enforces bounds `Writable`.
 - The governed host authorities are a *named* set — ssh-agent, docker, podman.
   DBus, Wayland, X11, gpg-agent, keyrings and arbitrary sockets stay reachable,
   so the claim is "these endpoints are governed", never "host IPC is isolated".
@@ -465,13 +456,9 @@ stop a connect. Possession is not authority: the key can be unreadable while an
 agent still signs with it.
 
 A protection claim exists only where a backend has a demonstrated enforcement
-primitive for that dimension. Unsupported dimensions stay explicitly unsupported,
-because a claim that outruns its enforcement is worse than an absent one: it is
-believed.
-
-Windows enforces Integrity on file creation only, when the user turns it on.
-Deletion and rename, Confidentiality and Authority (the named pipes of ssh-agent
-and docker, COM and RPC services) are not enforced there.
+primitive for that dimension. Unsupported dimensions stay explicitly unsupported
+— Windows currently enforces none of the three — because a claim that outruns
+its enforcement is worse than an absent one: it is believed.
 
 **Known unmeasured surface — macOS host-mediated delegation:** Apple Events and
 Mach-service lookup are not denied by the current allow-default profile. Prior

android/.gitignore

@@ -1,22 +0,0 @@
-# Build output and local tooling state.
-build/
-.gradle/
-.kotlin/
-local.properties
-*.iml
-.idea/
-
-# The signing key and the file that names it.
-#
-# A key is not part of the project: it is the identity one person ships under,
-# and publishing it would let anyone else sign an APK that installs over
-# everyone's. Neither the keystore nor its password belongs in version control.
-# `app/build.gradle` reads both from here when present and falls back to the
-# debug key when they are not, so a fresh clone builds without them.
-keystore/
-
-# Build inputs, produced by scripts/ before Gradle runs.
-# jniLibs/ holds the cross-compiled kernel, assets/page/ the built
-# frontend. assets/LICENSE is hand-placed and stays tracked.
-app/src/main/jniLibs/
-app/src/main/assets/page/

android/README.md

@@ -1,216 +0,0 @@
----
-owner: @esengine
-backup: @SivanCola
-status: active
-reviewed: 2026-10-20
----
-
-# Reasonix Mobile — the Android shell
-
-Runs Reasonix as an Android app: the kernel ships inside the APK and starts on the
-device, the interface is the same `desktop/frontend-next` build the desktop Studio
-serves, and the agent reaches servers over SSH.
-
-This file is for people building it. What a person installing it needs — what it
-does, how to pair with a computer, what it cannot do — belongs in the release
-notes.
-
-## One command
-
-```bash
-./scripts/build.sh release     # or debug
-```
-
-Three steps, in this order:
-
-1. `build-kernel.sh` → `app/src/main/jniLibs/arm64-v8a/libreasonix.so`
-2. `sync-page.sh` → `app/src/main/assets/page/`
-3. `./gradlew assembleRelease`
-
-Output: `app/build/outputs/apk/release/app-release.apk`
-
-The kernel and the page are **inputs to packaging, not Gradle build steps**.
-Running `gradle assembleRelease` on its own fails on purpose and names the script
-that produces whichever input is missing (`requireBuildInputs` in
-`app/build.gradle`): an APK with no kernel in it should not be buildable by
-accident.
-
-## Requirements
-
-| Component | Version |
-| --- | --- |
-| JDK | 21 (17 also works) |
-| Android SDK | `platforms;android-35`, `build-tools;35.0.0`, `platform-tools` |
-| Gradle | the committed wrapper, 8.14.3 (for AGP 8.11.1) |
-| Go | 1.26+ |
-| Node / pnpm | Node 24+ / pnpm 10 |
-
-```bash
-export ANDROID_HOME="$HOME/Android/Sdk"
-export ANDROID_SDK_ROOT="$ANDROID_HOME"
-export JAVA_HOME="/path/to/jdk-21"
-export PATH="$PATH:$(go env GOPATH)/bin"
-```
-
-`ANDROID_HOME` is the one thing nothing sets for you.
-
-## Scripts
-
-| Script | What it does |
-| --- | --- |
-| `build.sh [debug\|release]` | The whole chain |
-| `build-kernel.sh` | Cross-compiles the kernel only (`GOOS=android GOARCH=arm64 CGO_ENABLED=0`) |
-| `sync-page.sh` | Builds the frontend, copies `dist/` into assets, copies `LICENSE` |
-| `verify-page.sh` | **No phone needed**: starts the real kernel against the packaged page |
-| `run.sh [debug\|release]` | `adb install`, launch, follow the log |
-
-`verify-page.sh` is the one to run after a change: it starts the kernel with the
-same arguments `Kernel.kt` uses (`--auth token`, `--token-file`, `--port-file`,
-`-page`) and checks that it binds a port and answers 200. Without a device, that
-is as deep as the chain can be verified.
-
-## Where the code is
-
-| File | Owns |
-| --- | --- |
-| `MainActivity.kt` | The WebView, the back gesture, downloads, external links, renderer restart |
-| `Kernel.kt` | Unpacking the page, starting and stopping the kernel, waiting for the port, health probes, logs, the workspace directory |
-| `KernelService.kt` | The foreground service that keeps a long turn alive |
-| `NativeBridge.kt` | `@JavascriptInterface`: what the page may ask the phone for |
-| `BrowserShellServer.kt` | Loopback HTTP server the kernel's browser tools drive the overlay WebView through |
-| `Downloader.kt` | Writing a kernel-produced file through the system document picker |
-
-The page reaches the shell through `window.reasonixHost` and `ReasonixNative`,
-defined in `desktop/frontend-next/src/port/host.ts` (`AndroidHost`).
-
-**Phone and desktop share one page build.** What differs only on a phone is
-decided at runtime, not by a second set of components. `phoneShell()` in
-`src/port/host.ts` and the `[data-shell="android"]` selector in `mobile.css` both
-read `<html data-shell="android">`, which `index.html` sets before the bundle
-loads.
-
-One attribute feeding both is what keeps style and components from disagreeing
-about what a phone is.
-
-## What the page may ask the phone for
-
-`NativeBridge` is reachable from whatever document the WebView holds, so every
-method that touches the device asks `trusted()` first.
-
-The activity answers by comparing the **main frame's** origin against the
-kernel's and against the one paired computer the person scanned a code for. A
-page that navigated elsewhere is not trusted, even though it may still hold the
-object.
-
-Five methods answer without the check — `version`, `systemTheme`, `safeArea`,
-`setLayerOpen`, `setRunning` — because they report back what the page already
-knows about its own window and grant nothing.
-
-`openInApp(url)` is the pairing decision, not a navigation one: it loads a URL in
-this window only for the origin the scanner just returned, and only once.
-Without that, any page holding the kernel origin could hand itself the bridge.
-
-External links leave through the browser. A non-web scheme is routed to the
-system only for `mailto:` and `tel:`; everything else is dropped, because an
-`intent://` URL can start an arbitrary exported activity with caller-supplied
-extras.
-
-## Permissions, and what they cost
-
-`MANAGE_EXTERNAL_STORAGE` — opening a folder on the phone as a workspace. The
-kernel is a Go binary: it opens real paths with `open(2)`, and SAF hands back a
-`content://` URI it cannot open.
-
-Requested from the folder-picker action, never at launch. Android shows no dialog
-for it and opens system settings instead.
-
-**There is no OS-level sandbox around this kernel.** The PR sets the sandbox to
-off on Android, so confining the agent to the chosen folder is Reasonix's own
-write-root check and nothing else. A shell tool with all-files access can reach
-all shared storage.
-
-`REQUEST_IGNORE_BATTERY_OPTIMIZATIONS` — Doze freezes the app group, which stops
-a turn that is still running. Asked once when a turn actually runs, never at
-launch, and the person can refuse. Refusing costs battery life during long turns
-and nothing else.
-
-**Google Play restricts this permission**: fine for a sideloaded build, a
-store-policy risk if this is ever listed.
-
-`FOREGROUND_SERVICE` / `FOREGROUND_SERVICE_DATA_SYNC` — keeping the kernel alive
-while the screen is off. `dataSync` is capped per 24 hours from Android 15. It is
-the closest honest description of "an agent is working".
-
-`CAMERA` — reading the pairing code a computer shows. Requested when the person
-asks to scan, never at launch. `ScanActivity` is not exported.
-
-`READ_EXTERNAL_STORAGE` / `WRITE_EXTERNAL_STORAGE` — the same folder walk below
-API 33. `maxSdkVersion`-gated; above 33 they are superseded by the permission
-above.
-
-`allowBackup=false` with explicit extraction rules, so a `keystore` or a token in
-app storage never leaves the device in a cloud backup.
-
-## Cleartext HTTP
-
-The kernel serves its page on `127.0.0.1:<port>`, and a paired computer serves
-the same page over its LAN address. Both are plain HTTP.
-
-Neither address can be written into a `network-security-config`: the port is
-chosen at start, the LAN address at scan time, and the format matches literals
-and domains, not subnets.
-
-So the config permits cleartext and the boundary is in the code instead.
-`shouldOverrideUrlLoading` sends every other http(s) origin to the browser, and
-the bridge answers only the kernel and the just-paired computer. A plaintext page
-on the LAN cannot become the document holding the bridge.
-
-## What goes into the APK
-
-| Content | Size | Why it is shaped this way |
-| --- | --- | --- |
-| `lib/arm64-v8a/libreasonix.so` | 45 MB | Go static binary, stripped. It is a `.so` rather than a file in `assets/` because only `nativeLibraryDir` is guaranteed executable — a binary copied to app storage fails on a device whose data partition is mounted `noexec`. |
-| `assets/page/` | 14 MB | The frontend build, including the Inter and Noto Sans SC fonts, `noCompress` |
-| `assets/LICENSE` | 1 KB | The repository's MIT licence, verbatim. MIT requires the notice and the licence text to accompany a binary distribution. |
-
-`assets/LICENSE` is generated by `sync-page.sh` from the repository's root
-`LICENSE`, not committed a second time: a checked-in copy drifts when the root
-file is updated.
-
-It sits in `assets/` rather than `assets/page/` because that directory is removed
-and rebuilt on every build.
-
-A release APK is about 31 MB.
-
-## Building
-
-**The Gradle wrapper is committed**, jar and all. `build.sh` refuses to run
-without `gradlew` rather than generating one from whatever `gradle` is on `PATH`:
-the dependency versions are part of the build.
-
-`gradle-wrapper.properties` pins `distributionSha256Sum`, so a mirror that serves
-a different distribution zip fails verification instead of being unpacked and
-run. Dependency repositories are the official ones only — a mirror belongs in a
-user-level init script.
-
-**Signing.** A release with no key configured comes out **unsigned**
-(`app-release-unsigned.apk`) with a warning. It used to fall back to the debug
-key, which produced an artifact that looked shippable and was signed by a
-per-machine key nobody chose: it could not install over the previous build.
-
-Point the build at a real key by writing `keystore/keystore.properties`
-(`storeFile`, `storePassword`, `keyAlias`, and optionally `keyPassword`) or by
-setting the matching `REASONIX_KEYSTORE*` environment variables. Key material
-stays out of the repository and out of build logs.
-
-Debug builds always use the debug key. Signing a debug build with the release key
-would let anyone who can read the keystore produce a build that installs over the
-shipped one under the same signature.
-
-**Non-ASCII checkout paths.** AGP refuses to build under a path with non-ASCII
-characters on Windows unless `android.overridePathCheck=true` is set. That is a
-property of one machine's disk layout, not of this project, so it is not in the
-repository's `gradle.properties`.
-
-Set it in a user-level `~/.gradle/gradle.properties` or pass
-`-Pandroid.overridePathCheck=true`.

android/app/build.gradle

@@ -1,263 +0,0 @@
-// The app module.
-//
-// Two things ship inside the APK and neither is fetched at runtime: the kernel
-// binary, and the built page it serves. Bundling the page is what makes the app
-// work offline and start instantly; bundling the kernel is what lets it run
-// `reasonix serve` on the phone itself, which is the whole point — the agent
-// starts locally and reaches the server over SSH, so the interface, the model
-// catalogue and the credentials all live on the phone.
-//
-// The kernel is placed as `jniLibs/arm64-v8a/libreasonix.so`, not under
-// `assets/`. That is not a trick for its own sake: Android permits executing a
-// file under `nativeLibraryDir` and nothing under `filesDir` has that
-// guarantee, so a binary shipped the ordinary way would have to be copied out
-// and made executable at runtime — which fails outright on a device mounted
-// noexec, and fails confusingly on the ones that are merely unusual. `scripts/
-// build-kernel.sh` writes it there; the name is fixed by the packaging rules.
-plugins {
-    id "com.android.application"
-    id "org.jetbrains.kotlin.android"
-}
-
-// One version, read by the About screen and the update check.
-//
-// A published build takes its version from the tag it was cut for, so the About
-// screen and the update check name that release rather than the number this file
-// was last edited to. Without the property — a local build — the numbers below
-// are the answer.
-def publishedVersion = findProperty("reasonixVersion") as String
-def versionMajor = 2
-def versionMinor = 0
-def versionPatch = 0
-def versionBuild = 1
-if (publishedVersion) {
-    def parsed = publishedVersion =~ /^(\d+)\.(\d+)\.(\d+)/
-    if (!parsed.find()) {
-        throw new GradleException("reasonixVersion must start with MAJOR.MINOR.PATCH, got: ${publishedVersion}")
-    }
-    versionMajor = parsed.group(1) as int
-    versionMinor = parsed.group(2) as int
-    versionPatch = parsed.group(3) as int
-}
-
-// Where the two build inputs are expected. Both are produced from the checkout
-// beside this module, by the scripts named in each message.
-def upstream = rootProject.file("..")
-def pageDir = new File(projectDir, "src/main/assets/page")
-def kernelSo = new File(projectDir, "src/main/jniLibs/arm64-v8a/libreasonix.so")
-
-android {
-    namespace "io.reasonix.mobile.app"
-    compileSdk 35
-
-    defaultConfig {
-        applicationId "io.reasonix.mobile.app"
-        minSdk 26
-        // 35: the API level this app is actually built and tested against.
-        //
-        // It was briefly lowered to 26 while chasing an install failure that
-        // turned out to be a package-name collision with an unrelated app on the
-        // user's phone — the signature error named the wrong cause. Nothing about
-        // the target level ever caused it, so it goes back to the level the code
-        // is really written for.
-        //
-        // One consequence to keep in mind: from 35, Android 15 forces the window
-        // edge-to-edge and ignores a request to lay out inside the safe area. The
-        // window therefore *is* drawn under the status bar and the home indicator,
-        // and the only correct answer is for the page to pad itself — which is
-        // what `MainActivity` feeds real inset values for, since a WebView does
-        // not implement `env(safe-area-inset-*)`.
-        targetSdk 35
-        // versionCode must strictly increase, because Android refuses an update
-        // whose versionCode is not higher. The build digit is a single decimal
-        // place, so the scheme collides once a patch reaches 10: 2.55.10 and
-        // 2.56.0 both come out as 25601. Patch releases above 9 are not expected
-        // on Studio, and widening the digit now would renumber every build, so
-        // the constraint is recorded rather than fixed.
-        versionCode versionMajor * 10000 + versionMinor * 100 + versionPatch * 10 + versionBuild
-        versionName "${versionMajor}.${versionMinor}.${versionPatch}"
-
-        // The kernel is built for arm64 only, so every other ABI would ship an
-        // APK that installs and then cannot start. Naming the one real ABI keeps
-        // the store listing and the installer honest.
-        ndk {
-            abiFilters "arm64-v8a"
-        }
-
-        resourceConfigurations += ["zh", "en"]
-    }
-
-    // Android identifies an app by package name *and* signing key: an APK signed
-    // with a different key is not an update, it is an impostor, and the
-    // installer refuses it with "the signature does not match the installed
-    // app". Gradle's default release key is the debug key in the user's home
-    // directory, which is per-machine, so a build made on a second computer
-    // could never be installed over one made on the first.
-    //
-    // Whoever ships a build therefore pins a key — and that key is theirs, not
-    // the project's. It lives beside the checkout, in `keystore/`, which is
-    // ignored; so does the file naming it. A checkout without either signs with
-    // the debug key instead, which is what a contributor building locally wants
-    // and is what the README tells them to expect. Point the build at a real key
-    // by writing `keystore/keystore.properties` (storeFile, storePassword,
-    // keyAlias) or by setting REASONIX_KEYSTORE / REASONIX_KEYSTORE_PASSWORD /
-    // REASONIX_KEY_ALIAS.
-    def keyProperties = new Properties()
-    def keyPropertiesFile = rootProject.file("keystore/keystore.properties")
-    if (keyPropertiesFile.exists()) {
-        keyPropertiesFile.withInputStream { keyProperties.load(it) }
-    }
-    def keyStorePath = keyProperties.getProperty("storeFile") ?: System.getenv("REASONIX_KEYSTORE")
-    def keyStorePassword = keyProperties.getProperty("storePassword") ?: System.getenv("REASONIX_KEYSTORE_PASSWORD")
-    // The key's own password is a separate fact from the store's. PKCS#12 keystores
-    // almost always use one password for both, so falling back to the store's
-    // password keeps those working — but assuming they are equal is how a keystore
-    // that separates them gets a build failure at signing time, after the work is
-    // done, with an error that does not say which of the two was wrong.
-    def keyPasswordValue = keyProperties.getProperty("keyPassword") ?: System.getenv("REASONIX_KEY_PASSWORD") ?: keyStorePassword
-    def keyAliasName = keyProperties.getProperty("keyAlias") ?: System.getenv("REASONIX_KEY_ALIAS")
-    def haveReleaseKey = keyStorePath && keyStorePassword && keyAliasName &&
-            rootProject.file(keyStorePath).exists()
-
-    signingConfigs {
-        if (haveReleaseKey) {
-            releaseKey {
-                storeFile rootProject.file(keyStorePath)
-                storePassword keyStorePassword
-                keyAlias keyAliasName
-                keyPassword keyPasswordValue
-                // v1 is not optional here. Android 7+ reads v2 and ignores v1, so
-                // a v2-only APK installs on a modern phone — and then fails on the
-                // compatibility layers older devices and HarmonyOS' 卓易通 run,
-                // which know only the JAR signature and report its absence as a
-                // signature *mismatch*. Signing both is what makes one APK install
-                // everywhere.
-                enableV1Signing = true
-                enableV2Signing = true
-                enableV3Signing = true
-            }
-        }
-    }
-
-    // Nothing native is compiled here — the one .so is a prebuilt the kernel
-    // script writes — so the external native build is left alone entirely.
-    buildTypes {
-        debug {
-            applicationIdSuffix ".debug"
-            versionNameSuffix "-debug"
-            // The debug key, always. Signing a debug build with the release key
-            // would mean anyone who can read the release keystore can produce a
-            // build that installs over the shipped one under the same signature,
-            // and it buys nothing: the debug package is suffixed `.debug`, so the
-            // two already install side by side.
-        }
-        release {
-            // The kernel is a stripped Go binary and the page is minified, but
-            // the Kotlin shell still benefits and shipping the shrunk build is
-            // how a size regression gets noticed.
-            minifyEnabled true
-            shrinkResources true
-            proguardFiles getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"
-            // A release with no key of its own comes out *unsigned*
-            // (`app-release-unsigned.apk`). It used to fall back to the debug key
-            // so the artifact would install, which produced a release that looked
-            // shippable and was signed by a per-machine key nobody chose: it could
-            // not be installed over the previous build, and every machine made a
-            // different one. An unsigned artifact says what it is.
-            if (haveReleaseKey) {
-                signingConfig signingConfigs.releaseKey
-            } else {
-                logger.warn(
-                    "release build has no signing key: producing an unsigned APK. " +
-                        "Write keystore/keystore.properties (storeFile, storePassword, keyAlias) " +
-                        "or set REASONIX_KEYSTORE / REASONIX_KEYSTORE_PASSWORD / REASONIX_KEY_ALIAS."
-                )
-            }
-        }
-    }
-
-    compileOptions {
-        sourceCompatibility JavaVersion.VERSION_17
-        targetCompatibility JavaVersion.VERSION_17
-    }
-    kotlinOptions {
-        jvmTarget = "17"
-    }
-
-    buildFeatures {
-        // AGP 8 stops generating BuildConfig unless asked. `Kernel` reads the
-        // version name and code out of it to decide whether the bundled page
-        // needs unpacking, so it is asked for.
-        buildConfig = true
-    }
-
-    packaging {
-        jniLibs {
-            // `extractNativeLibs=true`: the kernel must exist as a real file on
-            // disk to be executed, and an uncompressed-and-mmap'd .so is not
-            // one. This is the only reason the flag is on.
-            useLegacyPackaging true
-        }
-        resources {
-            excludes += ["META-INF/*.version", "META-INF/*.kotlin_module", "kotlin/**", "DebugProbesKt.bin"]
-        }
-    }
-
-    // The page is read out of assets by `Kernel.publish`, not by the resource
-    // system, so it is not compressed — a page is already-compressed text and
-    // shrinking it again only costs startup time.
-    androidResources {
-        noCompress += ["json", "woff2", "ttf", "woff", "txt", "svg"]
-    }
-
-    lint {
-        abortOnError true
-        warningsAsErrors false
-        checkReleaseBuilds true
-    }
-}
-
-dependencies {
-    implementation "androidx.core:core-ktx:1.15.0"
-    implementation "androidx.appcompat:appcompat:1.7.0"
-    implementation "androidx.activity:activity-ktx:1.9.3"
-    implementation "androidx.webkit:webkit:1.12.1"
-    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.8.7"
-    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
-
-    // Scanning the pairing code a computer shows.
-    //
-    // CameraX for the preview and the frame stream, ZXing for the decode, and
-    // deliberately not ML Kit: this app installs on phones whose HarmonyOS
-    // compatibility layer has no Google Play Services, so a decoder that needs
-    // GMS would work on the developer's phone and fail on the user's. ZXing
-    // core is pure Java with no runtime dependency at all, which is what makes
-    // the scanner work on both.
-    implementation "androidx.camera:camera-core:1.4.1"
-    implementation "androidx.camera:camera-camera2:1.4.1"
-    implementation "androidx.camera:camera-lifecycle:1.4.1"
-    implementation "androidx.camera:camera-view:1.4.1"
-    implementation "com.google.zxing:core:3.5.3"
-}
-
-// Fail before the packaging step with something a person can act on, rather
-// than shipping an APK whose kernel is missing or whose page is a directory the
-// build never filled. The two messages name the script that produces each.
-tasks.register("requireBuildInputs") {
-    doFirst {
-        if (!kernelSo.exists()) {
-            throw new GradleException(
-                "内核二进制缺失：${kernelSo}\n先运行 ./scripts/build-kernel.sh（在 android/ 目录下）交叉编译内核。")
-        }
-        if (!pageDir.exists() || !new File(pageDir, "index.html").exists()) {
-            throw new GradleException(
-                "前端页面缺失：${pageDir}/index.html\n先运行 ./scripts/sync-page.sh（在 android/ 目录下）构建并同步页面。")
-        }
-    }
-}
-
-tasks.configureEach { task ->
-    if (task.name.startsWith("merge") && (task.name.contains("Assets") || task.name.contains("JniLibFolders"))) {
-        task.dependsOn("requireBuildInputs")
-    }
-}

android/app/proguard-rules.pro

@@ -1,32 +0,0 @@
-# R8 rules for the shell.
-#
-# There is very little to keep here, and that is the point: the app's own code
-# is reached from the manifest and from Android's own callbacks, both of which
-# R8 already traces, and nothing in it is loaded reflectively. What follows is
-# the two places where a name is looked up rather than called.
-
-# The WebView's JavaScript bridge, if one is ever added, is resolved by name on
-# the Java side and by the string the page uses. Keeping annotated members makes
-# that survive shrinking rather than failing at runtime with a method-not-found
-# that only shows up on a release build.
--keepclassmembers class * {
-    @android.webkit.JavascriptInterface <methods>;
-}
-
-# The Kernel's child process is started by absolute path, and its own log is
-# read as text; neither is reflective, so nothing else needs keeping.
-
-# Line numbers make a stack trace from a release build readable, which is the
-# only way a crash report from a phone can be acted on.
--keepattributes SourceFile,LineNumberTable
--renamesourcefileattribute SourceFile
-
-# Kotlin's `@Metadata` annotation is present on every class the compiler touched
-# and nothing in this app reflects over it. It is tempting to `-assumenosideeffects`
-# it away, and that was tried: any pattern broad enough to name its members also
-# matches the methods every class inherits from `Object` — `equals`, `hashCode`,
-# `toString` — and R8 then treats those as removable, which is a silent
-# behaviour change for a few kilobytes. Left as a warning suppression instead:
-# the annotation is dropped from the shrunk output anyway, because nothing reads
-# it.
--dontwarn kotlin.Metadata

android/app/src/main/AndroidManifest.xml

@@ -1,112 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  The shell's manifest.
-
-  There is no INTERNET-adjacent permission beyond INTERNET itself: the page and
-  the kernel talk over loopback, and reaching a server is the kernel's job over
-  a socket it owns. Reading and writing files goes through the system's document
-  picker (SAF), which hands back a grant for one file at a time — so no
-  storage permission is declared and none is needed.
-
-  `usesCleartextTraffic` is off here, and cleartext is re-enabled in the network
-  security config only because the kernel serves its page on `127.0.0.1` and a
-  paired computer serves the same page over its LAN address — both plain HTTP.
-  The config says what that costs and what bounds it.
--->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools">
-
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
-    <!-- Only to tell the person the kernel is still running while the screen is
-         off; it is a foreground service with a dismissible notification, not a
-         background wake-up. -->
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <!-- From API 34 every foreground-service *type* needs its own permission as
-         well as the general one: naming dataSync in the manifest without asking
-         for it is a SecurityException at startForeground, on the one code path
-         that keeps a long task alive. -->
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
-    <!-- Only to read the pairing code a computer shows. Requested at the
-         moment the person asks to scan, never at launch. -->
-    <uses-permission android:name="android.permission.CAMERA" />
-    <!-- The kernel is a child process, and a task left running is one the person
-         expects to finish with the screen off. Android's own doze can freeze the
-         whole app group instead, which is what the shell asks to be exempt from
-         — once, when a turn is actually running, never at launch. It is a
-         request the person can refuse, and refusing it only costs battery life
-         during a long turn. -->
-    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
-    <!-- Every-file access, for opening a folder on this phone as a workspace.
-         The kernel is a plain Go binary: it opens paths with `open(2)`, and a
-         document URI is not a path it can open. SAF would hand back exactly
-         that unusable URI, so the one honest permission is the broad one —
-         granted by the person in system settings, which is the only place
-         Android offers it. Nothing here reads storage for any other purpose. -->
-    <uses-permission
-        android:name="android.permission.MANAGE_EXTERNAL_STORAGE"
-        tools:ignore="ScopedStorage" />
-    <!-- Below API 33 the same folder walk needs the older pair; from 33 they are
-         superseded by the permission above and asking for them would be a lie. -->
-    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
-    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="29" />
-
-    <!-- A phone without a touchscreen cannot drive this interface; saying so
-         keeps the listing honest rather than letting it install on a TV. -->
-    <uses-feature android:name="android.hardware.touchscreen" android:required="true" />
-    <!-- The camera is optional: a phone without one is still a fine client for
-         a kernel it already knows, and it can still pair by opening the link the
-         computer shows. Requiring it would take the app off those devices. -->
-    <uses-feature android:name="android.hardware.camera" android:required="false" />
-    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />
-
-    <application
-        android:name=".App"
-        android:allowBackup="false"
-        android:dataExtractionRules="@xml/data_extraction_rules"
-        android:fullBackupContent="false"
-        android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
-        android:networkSecurityConfig="@xml/network_security_config"
-        android:supportsRtl="true"
-        android:theme="@style/Theme.Reasonix"
-        android:usesCleartextTraffic="false"
-        tools:targetApi="35">
-
-        <activity
-            android:name=".MainActivity"
-            android:exported="true"
-            android:configChanges="orientation|screenSize|screenLayout|keyboardHidden|uiMode|density|fontScale|smallestScreenSize"
-            android:launchMode="singleTask"
-            android:windowSoftInputMode="adjustResize"
-            android:theme="@style/Theme.Reasonix">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-
-        <!-- The kernel outlives the screen: a turn that takes minutes would
-             otherwise be killed when the phone is pocketed. The service is
-             `stopWithTask="false"` so swiping the app away ends it deliberately
-             rather than silently, and `foregroundServiceType="dataSync"` is the
-             closest honest description of "an agent is working". -->
-        <service
-            android:name=".KernelService"
-            android:exported="false"
-            android:foregroundServiceType="dataSync"
-            android:stopWithTask="false" />
-
-        <!-- Reading the pairing code a computer shows. Its own activity rather
-             than a dialog, because the camera preview needs the whole screen to
-             be worth pointing at anything. Not exported: only this app starts
-             it, and a scanner another app could open is one that could be made
-             to read a code on someone else's behalf. -->
-        <activity
-            android:name=".ScanActivity"
-            android:exported="false"
-            android:screenOrientation="portrait"
-            android:theme="@style/Theme.Reasonix.Scan" />
-    </application>
-</manifest>

android/app/src/main/java/io/reasonix/mobile/app/App.kt

@@ -1,59 +0,0 @@
-package io.reasonix.mobile.app
-
-import android.app.Application
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.content.Context
-
-/**
- * The process-wide facts this app needs.
- *
- * The kernel is one child process, so there is exactly one of it no matter how
- * many activities exist: it is held here, lazily, and the activity and the
- * service both reach the same instance. Nothing else is stored — the theme, the
- * language and every preference belong to the page and live in its localStorage.
- */
-class App : Application() {
-
-    /**
-     * The kernel, created on first use.
-     *
-     * Lazy rather than eager so that merely launching the process to answer a
-     * notification does not unpack a 15MB page.
-     */
-    val kernel: Kernel by lazy { Kernel(this) }
-
-    override fun onCreate() {
-        super.onCreate()
-        createChannel()
-    }
-
-    /**
-     * A channel the person can mute without muting the app, and one they can
-     * find: an agent that runs for minutes on a phone has to say so somewhere
-     * the system will not kill, and a notification is the only place Android
-     * offers. `IMPORTANCE_MIN` because the notification is a receipt, not an
-     * interruption — the work it reports is on another machine.
-     */
-    private fun createChannel() {
-        // No SDK_INT guard: minSdk is 26, which is the release NotificationChannel
-        // arrived in, so every device this app installs on has it.
-        val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        if (manager.getNotificationChannel(CHANNEL_KERNEL) != null) return
-        val channel = NotificationChannel(
-            CHANNEL_KERNEL,
-            getString(R.string.channel_kernel),
-            NotificationManager.IMPORTANCE_MIN,
-        ).apply {
-            description = getString(R.string.channel_kernel_desc)
-            setShowBadge(false)
-            enableVibration(false)
-            setSound(null, null)
-        }
-        manager.createNotificationChannel(channel)
-    }
-
-    companion object {
-        const val CHANNEL_KERNEL = "reasonix-kernel"
-    }
-}

android/app/src/main/java/io/reasonix/mobile/app/BrowserShellServer.kt

@@ -1,699 +0,0 @@
-package io.reasonix.mobile.app
-
-import android.graphics.Bitmap
-import android.graphics.Canvas
-import android.os.Handler
-import android.os.Looper
-import android.util.Base64
-import android.util.Log
-import android.webkit.WebView
-import org.json.JSONArray
-import org.json.JSONObject
-import java.io.BufferedInputStream
-import java.io.ByteArrayOutputStream
-import java.io.OutputStream
-import java.net.ServerSocket
-import java.net.Socket
-import java.net.SocketException
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.atomic.AtomicBoolean
-import java.util.concurrent.atomic.AtomicReference
-
-/**
- * The kernel's browser, as a loopback HTTP server.
- *
- * The Go kernel (`internal/platform/browser/shell.go`) drives a WebView by
- * POSTing JSON to a handful of paths on 127.0.0.1. This class is the other end
- * of that conversation: it accepts connections on a random port, parses the
- * minimal HTTP the kernel sends, and translates each path into an operation on
- * the overlay WebView.
- *
- * The server is deliberately tiny — no connection pooling, no keep-alive, no
- * chunked encoding — because the kernel is its only client and sends one
- * request per connection. A `ServerSocket` accept loop on a daemon thread is
- * the whole transport; each request is handled synchronously on its own thread.
- *
- * WebView operations must run on the UI thread. Each handler posts to the main
- * looper and waits on a latch, with a timeout that bounds the worst case (a
- * page that hangs the JS thread) to something the kernel's own 30-second client
- * timeout will not outlast.
- *
- * Memory note on `/screenshot`: a full-page `WebView.draw` into an ARGB_8888
- * bitmap at device resolution can reach tens of MB for a long page. The bitmap
- * is downsampled by a factor of 2 in each dimension before PNG encoding, which
- * keeps the peak allocation under ~10 MB for a typical 1080p viewport. The
- * original is recycled immediately after the downsample.
- */
-/** One thing a page asked the network for, as the WebView's request
- *  interceptor reports it. The interceptor is handed the method and the URL
- *  and nothing about the response, so a caller may show exactly this much and
- *  must not read it as a completed exchange. */
-data class BrowserRequest(val method: String, val url: String, val kind: String)
-
-class BrowserShellServer(
-    /** The overlay WebView, when one already exists. The routes that act on an
-     *  open page — back, forward, reload, close — use this: with no page there
-     *  is nothing to act on, and creating one to do nothing to it would start a
-     *  renderer nobody asked for. */
-    private val existingView: () -> WebView?,
-    /** The overlay WebView, created on first use. The routes that drive a page
-     *  use this, because the kernel can open one before the panel has ever been
-     *  shown: the page's own panel asks for the view when it is displayed, and
-     *  an agent's `browser_open` can arrive first. Requiring the view to exist
-     *  already answered every such call with "browser view not ready", which
-     *  reads as a broken engine rather than as a view that was not created yet.
-     *  Called on the UI thread. */
-    private val ensureView: () -> WebView,
-    /** Why the page in the view is the browser's own error page rather than a
-     *  site, as `(url, chromium error)`; null when the last load succeeded.
-     *  `/read` asks this, because extracting `innerText` from the error page
-     *  returns the browser's own "this page could not be loaded" notice, which
-     *  the kernel would hand to the model as though the site had said it. */
-    private val loadFailure: () -> Pair<String, String>? = { null },
-    /** Begin a navigation: forget the load failure recorded for the page being
-     *  left, drop its request list, and start the wait a following `/read`
-     *  joins. Called on the UI thread, before the new address is loaded, so the
-     *  wait is in place before any callback for the new page can fire. */
-    private val startNavigation: () -> Unit = {},
-    /** What the page currently in the view has asked the network for, oldest
-     *  first. The WebView reports a request's method and URL to its interceptor
-     *  but nothing about the response, so that is all a caller may show. */
-    private val requests: () -> List<BrowserRequest> = { emptyList() },
-    /** Wait for the navigation last asked for to settle — the page arrived, or
-     *  its load failed — up to the given milliseconds. Called on the request's
-     *  own thread, never the UI thread: the settle is signalled from the UI
-     *  thread, so waiting on it there would deadlock. `/load` starts a
-     *  navigation and returns before the page has been visited; without this a
-     *  `/read` right behind it still sees the URL of the page before, and a
-     *  failure recorded for that page was handed back as the new one's answer. */
-    private val awaitNavigation: (Long) -> Unit = {},
-) {
-
-    companion object {
-        private const val TAG = "BrowserShellServer"
-
-        /** How long a UI-thread operation may take before the handler gives up.
-         *  The kernel's client timeout is 30 s; staying under it means the kernel
-         *  sees a clean error rather than a dropped connection. */
-        private const val UI_TIMEOUT_MS = 25_000L
-
-        /** The maximum text `/read` returns. Matches the kernel's `maxReadText`
-         *  (400 << 10). The shell truncates here and says so, rather than letting
-         *  the kernel truncate silently. */
-        private const val MAX_READ_TEXT = 400 * 1024
-
-        /** Screenshot downsample factor. 2 means half width and half height. */
-        private const val SCREENSHOT_SCALE = 2
-
-        /** The address the kernel dials. Both ends must agree on the family:
-         *  see [start] for what goes wrong when they do not. */
-        private const val LOOPBACK_V4 = "127.0.0.1"
-
-        /** How long `/read` waits for a navigation it follows to settle before
-         *  reading whatever the view is on. A page that never finishes loading
-         *  must not hold the tool call open to the kernel's own timeout. */
-        private const val NAV_SETTLE_MS = 10_000L
-
-        /** How long `/read` then waits for the page's own script to answer.
-         *  `NAV_SETTLE_MS + READ_SCRIPT_MS` has to stay under [UI_TIMEOUT_MS],
-         *  and that under the kernel's 30-second client timeout: a read that
-         *  waited out both budgets would outlast the caller, which would see a
-         *  dropped connection instead of this shell's answer. 10 + 15 = 25 s. */
-        private const val READ_SCRIPT_MS = 15_000L
-    }
-
-    @Volatile
-    private var serverSocket: ServerSocket? = null
-
-    /** The port the server is listening on. Valid after [start] returns. */
-    @Volatile
-    var port: Int = 0
-        private set
-
-    /**
-     * The bearer credential every request must carry. Minted by the activity
-     * and handed to the kernel through the child's environment, so the server
-     * answers only the process this shell started.
-     *
-     * A phone's loopback is not a boundary: any other app may connect to
-     * 127.0.0.1, and the routes here run script in and read text out of
-     * whatever page is loaded. Binding to `getLoopbackAddress()` keeps other
-     * machines out but not other apps, so the credential is what makes "only
-     * the kernel this shell started" true.
-     */
-    @Volatile
-    var token: String = ""
-        private set
-
-    private val mainHandler = Handler(Looper.getMainLooper())
-
-    /**
-     * Start listening on 127.0.0.1 with an ephemeral port. The port is available
-     * via [port] immediately after this returns, and the credential the kernel
-     * must present via [token].
-     */
-    fun start() {
-        token = newToken()
-        // The loopback address is spelled out as IPv4, not taken from
-        // `InetAddress.getLoopbackAddress()`. That call is allowed to answer
-        // either family and Android's libcore answers IPv6 (`::1`), while the
-        // kernel's client is hardcoded to `http://127.0.0.1:<port>`
-        // (`internal/assembly/boot/browser.go`). A socket bound to `::1` does
-        // not answer a dial to `127.0.0.1`, so every browser call failed with
-        // "connection refused" while the port was bound and reported — the
-        // failure looked like a server that never started. Both ends have to
-        // name the same family, and IPv4 is the one the kernel names.
-        val ss = ServerSocket(0, 16, java.net.InetAddress.getByName(LOOPBACK_V4))
-        serverSocket = ss
-        port = ss.localPort
-        Log.i(TAG, "browser shell server listening on $LOOPBACK_V4:$port")
-
-        Thread({
-            while (!ss.isClosed) {
-                try {
-                    val client = ss.accept()
-                    Thread({ handleClient(client, token) }, "browser-shell-conn").apply { isDaemon = true }.start()
-                } catch (_: SocketException) {
-                    // Server was closed; exit the loop.
-                }
-            }
-        }, "browser-shell-accept").apply { isDaemon = true }.start()
-    }
-
-    fun stop() {
-        runCatching { serverSocket?.close() }
-        serverSocket = null
-    }
-
-    /** A fresh 256-bit credential, hex-encoded, for one launch of the server. */
-    private fun newToken(): String {
-        val bytes = ByteArray(32)
-        java.security.SecureRandom().nextBytes(bytes)
-        return bytes.joinToString("") { "%02x".format(it) }
-    }
-
-    // ---- HTTP plumbing --------------------------------------------------------
-
-    private fun handleClient(client: Socket, expected: String) {
-        try {
-            client.soTimeout = 30_000
-            val input = BufferedInputStream(client.getInputStream())
-            val output = client.getOutputStream()
-
-            // Parse the request line.
-            val requestLine = readLine(input) ?: return
-            val parts = requestLine.split(" ", limit = 3)
-            if (parts.size < 2) return
-            val method = parts[0]
-            val path = parts[1].substringBefore('?')
-
-            // Read headers.
-            var contentLength = 0
-            var bearer: String? = null
-            while (true) {
-                val header = readLine(input) ?: break
-                if (header.isEmpty()) break
-                val lower = header.lowercase()
-                if (lower.startsWith("content-length:")) {
-                    contentLength = header.substringAfter(':').trim().toIntOrNull() ?: 0
-                } else if (lower.startsWith("authorization:")) {
-                    bearer = header.substringAfter(':').trim().removePrefix("Bearer ").trim()
-                }
-            }
-
-            // Nothing behind this server is safe to hand out on the strength of
-            // an address: the port is on loopback, which any other app on the
-            // phone can dial, and the routes run script in and read text out of
-            // the loaded page. The credential the kernel was started with is the
-            // only thing that says a caller is that kernel. Every route is
-            // refused without it, /health included — a probe needs no exemption.
-            if (expected.isEmpty() || bearer != expected) {
-                writeResponse(output, 401, """{"error":"unauthorized"}""")
-                return
-            }
-
-            // Read body.
-            val body = if (contentLength > 0) {
-                val buf = ByteArray(contentLength)
-                var read = 0
-                while (read < contentLength) {
-                    val n = input.read(buf, read, contentLength - read)
-                    if (n == -1) break
-                    read += n
-                }
-                String(buf, 0, read, Charsets.UTF_8)
-            } else ""
-
-            // Route.
-            val (status, responseBody) = route(method, path, body)
-            writeResponse(output, status, responseBody)
-        } catch (e: Exception) {
-            Log.w(TAG, "connection error: ${e.message}")
-        } finally {
-            runCatching { client.close() }
-        }
-    }
-
-    private fun route(method: String, path: String, body: String): Pair<Int, String> {
-        return when {
-            method == "GET" && path == "/health" -> 200 to """{"ok":true}"""
-            method == "POST" && path == "/load" -> handleLoad(body)
-            method == "POST" && path == "/close" -> handleClose()
-            method == "POST" && path == "/read" -> handleRead()
-            method == "POST" && path == "/screenshot" -> handleScreenshot()
-            method == "POST" && path == "/click" -> handleClick(body)
-            method == "POST" && path == "/eval" -> handleEval(body)
-            method == "POST" && path == "/back" -> handleBack()
-            method == "POST" && path == "/forward" -> handleForward()
-            method == "POST" && path == "/reload" -> handleReload()
-            method == "POST" && path == "/requests" -> handleRequests()
-            else -> 404 to """{"error":"not found"}"""
-        }
-    }
-
-    private fun writeResponse(out: OutputStream, status: Int, body: String) {
-        val reason = when (status) {
-            200 -> "OK"
-            404 -> "Not Found"
-            500 -> "Internal Server Error"
-            else -> "Error"
-        }
-        val bytes = body.toByteArray(Charsets.UTF_8)
-        val header = "HTTP/1.1 $status $reason\r\n" +
-            "Content-Type: application/json\r\n" +
-            "Content-Length: ${bytes.size}\r\n" +
-            "Connection: close\r\n" +
-            "\r\n"
-        out.write(header.toByteArray(Charsets.UTF_8))
-        out.write(bytes)
-        out.flush()
-    }
-
-    private fun readLine(input: BufferedInputStream): String? {
-        val sb = StringBuilder()
-        while (true) {
-            val b = input.read()
-            if (b == -1) return if (sb.isEmpty()) null else sb.toString()
-            if (b == '\r'.code) {
-                val next = input.read()
-                if (next == '\n'.code) return sb.toString()
-                sb.append(b.toChar())
-                if (next != -1) sb.append(next.toChar())
-                continue
-            }
-            if (b == '\n'.code) return sb.toString()
-            sb.append(b.toChar())
-        }
-    }
-
-    // ---- endpoint handlers ----------------------------------------------------
-
-    /** POST /load {"url":"..."} → {"url":"...","title":"..."} */
-    private fun handleLoad(body: String): Pair<Int, String> {
-        val json = runCatching { JSONObject(body) }.getOrNull()
-            ?: return 500 to """{"error":"invalid request body"}"""
-        val url = json.optString("url", "")
-        if (url.isEmpty()) return 500 to """{"error":"missing url"}"""
-
-        val result = AtomicReference("")
-        val latch = CountDownLatch(1)
-        mainHandler.post {
-            val wv = ensureView()
-            // The failure recorded for the page being left stops being this
-            // tab's, and the wait a following `/read` joins is armed before the
-            // new address is loaded, so no callback for the new page can fire
-            // ahead of it. `/load` answers before the page arrives, which is
-            // what left the old failure to be read back as the new page's.
-            startNavigation()
-            wv.loadUrl(url)
-            // The title and final URL are not available synchronously after
-            // loadUrl; answer with what was requested. The kernel stores this
-            // as the tab's URL and reads the real one on the next /read.
-            result.set(JSONObject().apply {
-                put("url", url)
-                put("title", "")
-            }.toString())
-            latch.countDown()
-        }
-        if (!latch.await(UI_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
-            return 500 to """{"error":"timeout waiting for UI thread"}"""
-        }
-        return 200 to result.get()
-    }
-
-    /** POST /close {} → 200 */
-    private fun handleClose(): Pair<Int, String> {
-        val latch = CountDownLatch(1)
-        mainHandler.post {
-            val wv = existingView()
-            if (wv != null) {
-                wv.loadUrl("about:blank")
-                wv.clearHistory()
-            }
-            latch.countDown()
-        }
-        if (!latch.await(UI_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
-            return 500 to """{"error":"timeout"}"""
-        }
-        return 200 to "{}"
-    }
-
-    /**
-     * POST /read {} → {"title":"...","url":"...","text":"..."}
-     *
-     * Injects a script that extracts readable text from the page, preferring
-     * `<article>` or `<main>` and falling back to `body.innerText`. The result
-     * is truncated to 400 KB (matching the kernel's `maxReadText`); when
-     * truncated, a note is appended so the model knows the text was cut.
-     */
-    private fun handleRead(): Pair<Int, String> {
-        // The page the caller just asked for has not necessarily been visited
-        // yet: `/load` returns as soon as it has started the navigation. Waiting
-        // here, off the UI thread, is what makes this read answer about that
-        // page instead of the one before it.
-        awaitNavigation(NAV_SETTLE_MS)
-        val result = AtomicReference("")
-        val latch = CountDownLatch(1)
-        mainHandler.post {
-            val wv = ensureView()
-            // A page that did not load is not content. Whether the view is on
-            // the browser's own error page is read from the view itself rather
-            // than from a remembered failure: a failure recorded for the page
-            // before a new navigation would otherwise be handed back as this
-            // page's answer, long after the page the caller asked for had
-            // loaded. The remembered failure is still what names the address
-            // that failed and why, since the error page's own URL does not.
-            if ((wv.url ?: "").startsWith("chrome-error:")) {
-                val (url, reason) = loadFailure() ?: ((wv.url ?: "") to "ERR_FAILED")
-                result.set(JSONObject().apply {
-                    put("url", url)
-                    put("title", "")
-                    put("reason", reason)
-                    put("text", "")
-                }.toString())
-                latch.countDown()
-                return@post
-            }
-            // The extraction script: prefer article/main for content pages,
-            // fall back to body. innerText preserves visual line breaks. It
-            // also stamps a ref on every element a person could act on, so the
-            // kernel can name one in an act step the way the desktop backend
-            // names an accessibility node. A ref already on an element is kept,
-            // so it stays the same across snapshots of one document; a fresh
-            // document starts the numbering over, and the kernel only accepts a
-            // ref from the snapshot it last read.
-            val script = """
-                (function(){
-                    var seq = window.__rxRefSeq || 0;
-                    var used = {};
-                    var marked = document.querySelectorAll('[data-rx-ref]');
-                    for (var i = 0; i < marked.length; i++) { used[marked[i].getAttribute('data-rx-ref')] = true; }
-                    function roleOf(el) {
-                        var tag = el.tagName.toLowerCase();
-                        var role = (el.getAttribute('role') || '').toLowerCase();
-                        if (role) return role;
-                        if (tag === 'a') return 'link';
-                        if (tag === 'button') return 'button';
-                        if (tag === 'select') return 'combobox';
-                        if (tag === 'textarea') return 'textbox';
-                        if (tag === 'input') {
-                            var t = (el.getAttribute('type') || 'text').toLowerCase();
-                            if (t === 'checkbox' || t === 'radio' || t === 'submit' || t === 'button' || t === 'reset') return t;
-                            return 'textbox';
-                        }
-                        return 'generic';
-                    }
-                    function nameOf(el) {
-                        var n = el.getAttribute('aria-label') || el.getAttribute('placeholder') || el.getAttribute('name') || '';
-                        if (!n) { n = (el.innerText || el.textContent || '').trim(); }
-                        return n.replace(/\s+/g, ' ').slice(0, 160);
-                    }
-                    var sel = 'a[href],button,input,select,textarea,[role=button],[role=link],[role=checkbox],[role=radio],[role=tab],[role=menuitem],[contenteditable=true]';
-                    var els = document.querySelectorAll(sel);
-                    var elements = [];
-                    for (var j = 0; j < els.length; j++) {
-                        var el = els[j];
-                        var ref = el.getAttribute('data-rx-ref');
-                        if (!ref) {
-                            do { seq++; ref = 'e' + seq; } while (used[ref]);
-                            el.setAttribute('data-rx-ref', ref);
-                            used[ref] = true;
-                        }
-                        var raw = (el.value != null && String(el.value) !== '') ? String(el.value).slice(0, 160) : '';
-                        elements.push({ref: ref, role: roleOf(el), name: nameOf(el), value: raw});
-                    }
-                    window.__rxRefSeq = seq;
-                    var el2 = document.querySelector('article') || document.querySelector('main') || document.body;
-                    var text = el2 ? (el2.innerText || '') : '';
-                    var title = document.title || '';
-                    var url = location.href;
-                    return JSON.stringify({title: title, url: url, text: text, elements: elements});
-                })()
-            """.trimIndent()
-            wv.evaluateJavascript(script) { value ->
-                // evaluateJavascript returns a JSON-encoded string (the result
-                // is double-encoded). Strip the outer quotes.
-                val parsed = parseJsResult(value)
-                if (parsed != null) {
-                    try {
-                        val obj = JSONObject(parsed)
-                        var text = obj.optString("text", "")
-                        if (text.length > MAX_READ_TEXT) {
-                            text = text.substring(0, MAX_READ_TEXT) +
-                                "\n\n[text truncated at 400 KB]"
-                        }
-                        result.set(JSONObject().apply {
-                            put("title", obj.optString("title", ""))
-                            put("url", obj.optString("url", ""))
-                            put("text", text)
-                            put("elements", obj.optJSONArray("elements") ?: JSONArray())
-                        }.toString())
-                    } catch (e: Exception) {
-                        result.set(JSONObject().apply {
-                            put("title", "")
-                            put("url", wv.url ?: "")
-                            put("text", parsed.take(MAX_READ_TEXT))
-                        }.toString())
-                    }
-                } else {
-                    result.set(JSONObject().apply {
-                        put("title", "")
-                        put("url", wv.url ?: "")
-                        put("text", "")
-                    }.toString())
-                }
-                latch.countDown()
-            }
-        }
-        if (!latch.await(READ_SCRIPT_MS, TimeUnit.MILLISECONDS)) {
-            return 500 to """{"error":"timeout waiting for page script"}"""
-        }
-        return 200 to result.get()
-    }
-
-    /**
-     * POST /screenshot {} → {"data":"<base64>","mime":"image/png"}
-     *
-     * Draws the WebView into a bitmap, downsamples by SCREENSHOT_SCALE to keep
-     * memory bounded, and encodes as PNG → base64. For a 1080×2400 viewport the
-     * full bitmap is ~10 MB; the downsampled one is ~2.5 MB. The full bitmap is
-     * recycled immediately after scaling.
-     */
-    private fun handleScreenshot(): Pair<Int, String> {
-        val result = AtomicReference("")
-        val failed = AtomicBoolean(false)
-        val latch = CountDownLatch(1)
-        mainHandler.post {
-            val wv = ensureView()
-            try {
-                val width = wv.width.takeIf { it > 0 } ?: 1080
-                val height = wv.height.takeIf { it > 0 } ?: 1920
-                val bmp = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
-                val canvas = Canvas(bmp)
-                wv.draw(canvas)
-
-                // Downsample to bound the PNG size and the base64 string.
-                val scaled = Bitmap.createScaledBitmap(
-                    bmp,
-                    width / SCREENSHOT_SCALE,
-                    height / SCREENSHOT_SCALE,
-                    true,
-                )
-                if (scaled !== bmp) bmp.recycle()
-
-                val baos = ByteArrayOutputStream()
-                scaled.compress(Bitmap.CompressFormat.PNG, 85, baos)
-                scaled.recycle()
-                val b64 = Base64.encodeToString(baos.toByteArray(), Base64.NO_WRAP)
-                result.set(JSONObject().apply {
-                    put("data", b64)
-                    put("mime", "image/png")
-                }.toString())
-            } catch (e: Exception) {
-                // A 200 with an error body would be read by the kernel as a
-                // screenshot whose data is empty, and it would build a `data:`
-                // URI out of nothing. The status is what tells it this failed.
-                result.set("""{"error":"screenshot failed: ${e.message}"}""")
-                failed.set(true)
-            }
-            latch.countDown()
-        }
-        if (!latch.await(UI_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
-            return 500 to """{"error":"timeout"}"""
-        }
-        if (failed.get()) return 500 to result.get()
-        return 200 to result.get()
-    }
-
-    /** POST /click {"selector":"..."} → {"ok":true|false} */
-    private fun handleClick(body: String): Pair<Int, String> {
-        val json = runCatching { JSONObject(body) }.getOrNull()
-            ?: return 500 to """{"error":"invalid request body"}"""
-        val selector = json.optString("selector", "")
-        if (selector.isEmpty()) return 500 to """{"error":"missing selector"}"""
-
-        val result = AtomicReference("")
-        val latch = CountDownLatch(1)
-        mainHandler.post {
-            val wv = ensureView()
-            // Escape the selector for embedding in a JS string.
-            val escaped = selector.replace("\\", "\\\\").replace("'", "\\'")
-            val script = """
-                (function(){
-                    try {
-                        var el = document.querySelector('$escaped');
-                        if (!el) return JSON.stringify({ok: false});
-                        el.click();
-                        return JSON.stringify({ok: true});
-                    } catch(e) {
-                        return JSON.stringify({ok: false});
-                    }
-                })()
-            """.trimIndent()
-            wv.evaluateJavascript(script) { value ->
-                val parsed = parseJsResult(value)
-                result.set(parsed ?: """{"ok":false}""")
-                latch.countDown()
-            }
-        }
-        if (!latch.await(UI_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
-            return 500 to """{"error":"timeout"}"""
-        }
-        return 200 to result.get()
-    }
-
-    /** POST /eval {"script":"..."} → {"result":"..."} */
-    private fun handleEval(body: String): Pair<Int, String> {
-        val json = runCatching { JSONObject(body) }.getOrNull()
-            ?: return 500 to """{"error":"invalid request body"}"""
-        val script = json.optString("script", "")
-        if (script.isEmpty()) return 500 to """{"error":"missing script"}"""
-
-        val result = AtomicReference("")
-        val latch = CountDownLatch(1)
-        mainHandler.post {
-            val wv = ensureView()
-            wv.evaluateJavascript(script) { value ->
-                // The kernel expects a plain string in "result". The value from
-                // evaluateJavascript is JSON-encoded; unwrap it.
-                val unwrapped = parseJsResult(value) ?: ""
-                result.set(JSONObject().apply {
-                    put("result", unwrapped)
-                }.toString())
-                latch.countDown()
-            }
-        }
-        if (!latch.await(UI_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
-            return 500 to """{"error":"timeout waiting for eval"}"""
-        }
-        return 200 to result.get()
-    }
-
-    /** POST /back → 200 */
-    private fun handleBack(): Pair<Int, String> {
-        val latch = CountDownLatch(1)
-        mainHandler.post {
-            existingView()?.let { if (it.canGoBack()) it.goBack() }
-            latch.countDown()
-        }
-        if (!latch.await(UI_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
-            return 500 to """{"error":"timeout"}"""
-        }
-        return 200 to "{}"
-    }
-
-    /** POST /forward → 200 */
-    private fun handleForward(): Pair<Int, String> {
-        val latch = CountDownLatch(1)
-        mainHandler.post {
-            existingView()?.let { if (it.canGoForward()) it.goForward() }
-            latch.countDown()
-        }
-        if (!latch.await(UI_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
-            return 500 to """{"error":"timeout"}"""
-        }
-        return 200 to "{}"
-    }
-
-    /** POST /reload → 200 */
-    private fun handleReload(): Pair<Int, String> {
-        val latch = CountDownLatch(1)
-        mainHandler.post {
-            val wv = existingView()
-            // A view sitting on the browser's own error page is not on the site,
-            // and reloading it would retry the error page itself. The address
-            // that failed is loaded again instead — which is the page a caller
-            // means by "reload" — read before `startNavigation` clears it.
-            val failed = if (wv != null && (wv.url ?: "").startsWith("chrome-error:"))
-                loadFailure()?.first else null
-            startNavigation()
-            if (wv != null) {
-                if (failed != null) wv.loadUrl(failed) else wv.reload()
-            }
-            latch.countDown()
-        }
-        if (!latch.await(UI_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
-            return 500 to """{"error":"timeout"}"""
-        }
-        return 200 to "{}"
-    }
-
-    /** POST /requests {} → {"requests":[{"method","url","kind"},…]} */
-    private fun handleRequests(): Pair<Int, String> {
-        val arr = JSONArray()
-        for (r in requests()) {
-            arr.put(JSONObject().apply {
-                put("method", r.method)
-                put("url", r.url)
-                put("kind", r.kind)
-            })
-        }
-        return 200 to JSONObject().apply { put("requests", arr) }.toString()
-    }
-
-    // ---- helpers ----------------------------------------------------------------
-
-    /**
-     * Unwrap the result of `evaluateJavascript`. The callback receives a
-     * JSON-encoded string: a JS string "hello" arrives as `"\"hello\""`, a
-     * number 42 as `"42"`, null as `"null"`. Strip the outer JSON encoding to
-     * get the raw value.
-     */
-    private fun parseJsResult(value: String?): String? {
-        if (value == null || value == "null") return null
-        // The value is a JSON literal. If it is a JSON string, decode it.
-        return try {
-            if (value.startsWith("\"") && value.endsWith("\"")) {
-                JSONObject().apply { }.let {
-                    // Use JSONObject's string decoding: wrap in an object.
-                    JSONObject("""{"v":$value}""").optString("v", "")
-                }
-            } else {
-                value
-            }
-        } catch (_: Exception) {
-            value
-        }
-    }
-}

android/app/src/main/java/io/reasonix/mobile/app/Dns.kt

@@ -1,119 +0,0 @@
-package io.reasonix.mobile.app
-
-import android.content.Context
-import android.net.ConnectivityManager
-import android.net.LinkProperties
-import android.os.Build
-
-/**
- * The phone's DNS servers, as the kernel needs them.
- *
- * The kernel is a CGO-free Go binary, and Go's own source explains why that
- * matters:
- *
- * ```
- * // DNS requests don't work on Android, so prefer the cgo resolver.
- * // Issue #10714.
- * case "android":
- * ```
- *
- * A normal Android program resolves names through `getaddrinfo`, which reaches
- * the `netd` daemon and gets the servers of the network that is actually up.
- * A static binary has no cgo resolver, so Go reads `/etc/resolv.conf` instead —
- * and Android has no such file. Go then falls back to `127.0.0.1:53`, where
- * nothing listens, and every lookup fails: the setup screen reports
- * "连接失败" for every provider, including the official ones, on a phone whose
- * browser reaches them fine.
- *
- * So they are read here and handed to the kernel through `REASONIX_DNS`. This is
- * the same source the system itself uses, so a VPN, a private DNS hostname, or a
- * network that changed since boot is all reflected without this code knowing
- * anything about them.
- */
-object Dns {
-
-    /**
-     * The active network's servers, comma separated, or "" when there is none.
-     *
-     * Read from the *active* network rather than from every link, because a phone
-     * commonly has several at once — Wi-Fi, mobile data, a VPN — and the servers
-     * of a network that is not carrying traffic are the wrong ones to ask.
-     */
-    fun servers(context: Context): String {
-        val manager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
-            ?: return ""
-        val properties: LinkProperties = runCatching { manager.activeNetwork }.getOrNull()
-            ?.let { network -> runCatching { manager.getLinkProperties(network) }.getOrNull() }
-            ?: return ""
-        return properties.dnsServers
-            .mapNotNull { address -> address.hostAddress }
-            .filter { it.isNotBlank() }
-            .filter { routable(it) }
-            .sortedBy { preference(it) }
-            .joinToString(",")
-    }
-
-    /**
-     * Whether an address can actually carry a query.
-     *
-     * A link-local address (fe80::/10) without its zone cannot: the packet has
-     * no interface to leave by, so it is dropped, nothing answers, and the
-     * lookup hangs until the kernel's own timeout expires — which is reported as
-     * a timeout rather than as a failure to resolve, and so reads like the
-     * network is slow instead of like the address is unusable.
-     *
-     * Android reports the zone as a `%wlan0` suffix on `hostAddress`, and the
-     * address is only usable with it kept. Nothing here trims it: an earlier
-     * version called `substringBefore('%')`, which turned a usable link-local
-     * server into an unroutable one.
-     */
-    private fun routable(host: String): Boolean =
-        !(host.startsWith("fe80:", ignoreCase = true) && !host.contains('%'))
-
-    /**
-     * IPv4 first, then IPv6.
-     *
-     * A phone commonly reports both, and its IPv6 entry is often a router's
-     * link-local address — reachable on one network and not the next. The
-     * kernel tries the servers in the order it is given them, and stops at the
-     * first that answers; putting the address family that shares the network's
-     * own numbering first means its timeout is spent on a server that works.
-     */
-    private fun preference(host: String): Int = if (host.contains(':')) 1 else 0
-
-    /**
-     * The private-DNS setting, for the one case the address list cannot answer.
-     *
-     * Since Android 9 a phone may use DNS-over-TLS, and then `dnsServers` holds a
-     * name rather than an address — a name this kernel cannot resolve *because*
-     * resolving it is the thing that is broken. There is no way for the shell to
-     * do that lookup for it, so this reports the situation instead of handing
-     * over an unusable value: the caller says so in the log, and the person can
-     * turn private DNS off or set it to automatic.
-     */
-    fun looksLikeDot(servers: String): Boolean =
-        servers.isNotBlank() && servers.split(',').any { part ->
-            val host = part.trim()
-            host.isNotEmpty() && host.none { it == ':' } && !host.all { it.isDigit() || it == '.' }
-        }
-
-    /** Whether the system requires a VPN or private DNS, which changes nothing
-     *  here but is worth saying in a bug report. */
-    fun describe(context: Context): String {
-        val manager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
-            ?: return "no connectivity service"
-        val network = runCatching { manager.activeNetwork }.getOrNull() ?: return "no active network"
-        val properties = runCatching { manager.getLinkProperties(network) }.getOrNull()
-            ?: return "no link properties"
-        // The DHCP server arrived in API 30, not 23: asked for below that it is a
-        // NoSuchMethodError on a device this app supports (minSdk 26), and the
-        // answer is only ever read out of this string by a person debugging.
-        val dhcp = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-            properties.dhcpServerAddress?.hostAddress
-        } else {
-            null
-        }
-        return "iface=${properties.interfaceName} dns=${properties.dnsServers.joinToString(",") { it.hostAddress ?: "?" }}" +
-            (dhcp?.let { " dhcp=$it" } ?: "")
-    }
-}

android/app/src/main/java/io/reasonix/mobile/app/Downloader.kt

@@ -1,87 +0,0 @@
-package io.reasonix.mobile.app
-
-import android.content.Context
-import android.net.Uri
-import android.webkit.CookieManager
-import android.widget.Toast
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import java.io.FileNotFoundException
-import java.net.HttpURLConnection
-import java.net.URL
-
-/**
- * Putting a file the page produced onto the phone's disk.
- *
- * A WebView has no downloads shelf and cannot write to the system's document
- * picker itself, so the two halves are joined here: the page asks, the picker
- * answers with a `content://` the app has been granted, and this copies the
- * bytes across.
- *
- * The request carries the WebView's own cookie, read out of the jar the page
- * authenticated in. That is the only reason this is not a plain `openStream`:
- * the kernel's download route is behind the session the page established, and a
- * shell that fetched without it would get a 403 and no explanation.
- */
-object Downloader {
-
-    suspend fun run(
-        context: Context,
-        url: String,
-        userAgent: String,
-        mime: String,
-        name: String,
-        target: Uri,
-    ): Result<Unit> = withContext(Dispatchers.IO) {
-        runCatching {
-            val connection = (URL(url).openConnection() as HttpURLConnection).apply {
-                connectTimeout = 15_000
-                readTimeout = 60_000
-                requestMethod = "GET"
-                if (userAgent.isNotBlank()) setRequestProperty("User-Agent", userAgent)
-                // The download route answers with the same session cookie the
-                // page is using; without it the kernel refuses the request.
-                cookieFor(url)?.let { setRequestProperty("Cookie", it) }
-            }
-            try {
-                val code = connection.responseCode
-                if (code !in 200..299) {
-                    throw IllegalStateException(
-                        context.getString(R.string.download_failed_status, code),
-                    )
-                }
-                val resolver = context.contentResolver
-                val output = resolver.openOutputStream(target, "w")
-                    ?: throw FileNotFoundException(target.toString())
-                output.use { out ->
-                    connection.inputStream.use { input -> input.copyTo(out) }
-                }
-                // `copyTo` answers with a byte count; what the caller wants to
-                // know is that there were no bytes missing, not how many.
-                Unit
-            } finally {
-                connection.disconnect()
-            }
-        }
-    }
-
-    /**
-     * The cookie the page authenticated with, if any.
-     *
-     * `CookieManager` is the WebView's own store, so this asks the exact jar the
-     * request will be checked against rather than a copy this shell kept.
-     */
-    private fun cookieFor(url: String): String? =
-        runCatching { CookieManager.getInstance().getCookie(url) }.getOrNull()?.takeIf { it.isNotBlank() }
-
-    /** A short receipt for a tap that otherwise does nothing visible. */
-    fun report(context: Context, name: String, result: Result<Unit>) {
-        val message = result.fold(
-            onSuccess = { context.getString(R.string.download_saved, name) },
-            onFailure = { failure ->
-                context.getString(R.string.download_failed, failure.message ?: "")
-            },
-        )
-        Toast.makeText(context, message, Toast.LENGTH_LONG).show()
-    }
-}

android/app/src/main/java/io/reasonix/mobile/app/Kernel.kt

@@ -1,741 +0,0 @@
-package io.reasonix.mobile.app
-
-import android.content.Context
-import android.content.res.AssetManager
-import org.json.JSONArray
-import org.json.JSONObject
-import android.util.Log
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.withContext
-import java.io.File
-import java.io.FileOutputStream
-import java.net.HttpURLConnection
-import java.net.URL
-import java.security.SecureRandom
-import java.util.Locale
-
-/**
- * The Reasonix kernel, as this app runs it: one child process serving loopback,
- * plus the two things it needs on disk to start — the page it serves and a
- * credential for this launch.
- *
- * The shape is the desktop host's (`cmd/reasonix-studio-host`), narrowed to what
- * a phone does not have. That host binds a socket, mints a credential, speaks a
- * handshake down a pipe and holds a lease; here the credential goes through
- * `--token-file` and the bound address through `--port-file`, because a phone's
- * app process has no pipe to hand a child and no reason to care which port was
- * free. Everything after that — the kernel's own gate, its auth middleware, its
- * CSRF check — is untouched, so the security of the surface is the one upstream
- * tested, not one this shell invented.
- *
- * One instance lives in the app process. The activity asks it for a URL; the
- * foreground service asks it to stay alive. Both see the same process, so there
- * is nothing to synchronise beyond a lock on start/stop.
- */
-class Kernel(private val context: Context) {
-
-    /** Where everything the kernel owns lives. Nothing here is backed up. */
-    private val home = File(context.filesDir, "home")
-
-    /**
-     * The folder the agent works in, which is not the folder the kernel lives in.
-     *
-     * These used to be the same directory, and that is what made the workbench
-     * unreadable: the kernel's home holds `config.toml`, `projects/`, `cache/`,
-     * `stats/` and the rest of its own bookkeeping, and a workspace pointed at
-     * it shows all of that as if the person had put it there. Reported as "why
-     * does the default workspace have so many files, the desktop version does
-     * not generate these" — the desktop does generate them, in a different
-     * directory, because its workspace is whatever folder it was opened on.
-     *
-     * Split apart, the workbench shows what the agent produced and nothing else.
-     * `write_roots` follows the workspace, so the file tools stay confined to
-     * the folder the person actually works in rather than to the kernel's own
-     * home — which is the stricter answer, and the one the desktop already has.
-     */
-    private val workspaceDir = File(context.filesDir, "workspace")
-
-    /**
-     * The directory the kernel calls `REASONIX_HOME`, for the one caller that
-     * has to put a file where the kernel can read it — a private key the person
-     * picked from their Documents folder.
-     */
-    fun homeDir(): File = home
-
-    /** The folder the agent works in. */
-    fun workspaceDir(): File = workspaceDir
-
-    /** The built page, unpacked once per version. */
-    private val pageDir = File(context.filesDir, "page")
-
-    private val tokenFile = File(home, "remote/launch.token")
-    private val portFile = File(home, "remote/serve.port")
-    private val pidFile = File(home, "remote/serve.pid")
-
-    private val lock = Any()
-
-    @Volatile
-    private var process: Process? = null
-
-    /** The port the shell's browser HTTP server listens on, set by the
-     *  activity before `start()` is called. Zero means no server is up, and
-     *  the kernel leaves its browser tools suspended (the correct degradation
-     *  on a phone with no Chromium). */
-    @Volatile
-    var browserShellPort: Int = 0
-
-    /** The bearer credential for that server, set beside the port. Sent on
-     *  every browser call so the server can refuse anything that did not come
-     *  from the kernel this shell started — loopback on a phone is reachable
-     *  by every other app. Empty when there is no server. */
-    @Volatile
-    var browserShellToken: String = ""
-
-    /** What the WebView should load, once the kernel has bound a port. */
-    @Volatile
-    var origin: String? = null
-        private set
-
-    /**
-     * The launch credential, as the URL fragment the page trades for a cookie.
-     * Kept in memory only: the file on disk belongs to the kernel's own
-     * bookkeeping, and a phone's app data is not a place to leave a second copy.
-     */
-    @Volatile
-    private var token: String? = null
-
-    /**
-     * The URL the WebView loads first. It carries the credential in the
-     * fragment, which the page exchanges for an HttpOnly cookie before it makes
-     * any request — the same path a shared `reasonix web` link takes, so the
-     * token never enters a request line, a history entry or a log.
-     */
-    fun entryUrl(): String? {
-        val origin = origin ?: return null
-        val token = token ?: return null
-        return "$origin/#token=$token"
-    }
-
-    /** The plain origin, for reloads once the cookie is set. */
-    fun plainUrl(): String? = origin
-
-    fun isRunning(): Boolean = process?.isAlive == true
-
-    /**
-     * Bring the kernel up, or answer the URL of the one already up.
-     *
-     * Starting is idempotent by intent: the activity and the service both call
-     * this, and whichever arrives second joins the running kernel instead of
-     * racing it for the port.
-     */
-    suspend fun start(): Result<String> = withContext(Dispatchers.IO) {
-        synchronized(lock) {
-            origin?.let { return@withContext Result.success(it) }
-
-            runCatching {
-                val binary = kernelBinary()
-                publishPage()
-                prepareHome()
-                val launchToken = mintToken()
-                token = launchToken
-
-                val child = launch(binary, launchToken)
-
-                // The port is the kernel's answer, not this shell's guess. It
-                // writes the file after binding, so waiting on the file is
-                // waiting on the bind.
-                val bound = awaitPort(child)
-                val url = "http://$bound"
-
-                // A kernel that bound a port and then died would look healthy
-                // here and broken in the WebView; the two facts are checked
-                // together, and only a kernel that is answering is adopted.
-                awaitServing(child, url)
-                origin = url
-                process = child
-                url
-            }.onFailure { origin = null; process = null }
-        }
-    }
-
-    /**
-     * Stop the kernel.
-     *
-     * The graceful signal first: the kernel drains its listeners and closes the
-     * runtimes it opened, which is what lets a later launch adopt the sessions
-     * rather than find them locked. `destroyForcibly` is the second attempt, and
-     * only after a wait — a phone that is being shut down should not keep a
-     * half-killed agent.
-     */
-    fun stop() {
-        synchronized(lock) {
-            val p = process ?: return
-            process = null
-            origin = null
-            token = null
-            runCatching {
-                p.destroy()
-                if (!p.waitFor(3, java.util.concurrent.TimeUnit.SECONDS)) {
-                    p.destroyForcibly()
-                }
-            }
-            portFile.delete()
-            pidFile.delete()
-        }
-    }
-
-    // ---- the two inputs that ship inside the APK -------------------------
-
-    /**
-     * The kernel binary.
-     *
-     * It is packaged as a native library, so Android has already extracted it to
-     * a directory it allows execution from and given it the executable bit —
-     * which is the one thing a file under app storage does not get for free.
-     */
-    private fun kernelBinary(): File {
-        val dir = File(context.applicationInfo.nativeLibraryDir)
-        val binary = File(dir, "libreasonix.so")
-        if (!binary.exists()) {
-            throw IllegalStateException(
-                "内核未随 APK 安装：${binary.path}\n这是一次构建问题，请重新安装完整 APK。",
-            )
-        }
-        return binary
-    }
-
-    /**
-     * Write the bundled page where the kernel can serve it.
-     *
-     * It goes to app storage rather than being served out of the APK because the
-     * kernel's `--page` is a directory on a real filesystem; there is no
-     * archive-aware variant, and adding one would be a change to the kernel for
-     * this shell's convenience alone.
-     *
-     * Unpacking is versioned: the marker holds the app's version name, so an
-     * update replaces the page and a relaunch does not. A partially written
-     * directory — the app killed mid-copy — is caught by the same marker never
-     * having been written, so the next launch rewrites it.
-     */
-    private fun publishPage() {
-        val marker = File(pageDir, ".unpacked")
-        val stamp = "${BuildConfig.VERSION_NAME}:${BuildConfig.VERSION_CODE}"
-        if (marker.isFile && marker.readText().trim() == stamp) return
-
-        pageDir.deleteRecursively()
-        pageDir.mkdirs()
-        copyAssetTree(context.assets, "page", pageDir)
-
-        if (!File(pageDir, "index.html").isFile) {
-            throw IllegalStateException("随 APK 分发的页面不完整：缺少 index.html")
-        }
-        marker.writeText(stamp)
-    }
-
-    /**
-     * A directory tree out of assets.
-     *
-     * `AssetManager.list` on a file answers with an empty array, so a "file" is
-     * told from a directory by trying to open it — which is the only signal the
-     * API offers and the reason this is not a one-liner.
-     */
-    private fun copyAssetTree(assets: AssetManager, from: String, to: File) {
-        val children = assets.list(from).orEmpty()
-        if (children.isEmpty()) {
-            // A leaf: open it as a stream. A directory that happens to be empty
-            // is indistinguishable and harmless to skip.
-            runCatching {
-                assets.open(from).use { input ->
-                    FileOutputStream(to).use { output -> input.copyTo(output) }
-                }
-            }
-            return
-        }
-        to.mkdirs()
-        for (child in children) {
-            copyAssetTree(assets, "$from/$child", File(to, child))
-        }
-    }
-
-    /**
-     * Prepare the kernel's home.
-     *
-     * `REASONIX_HOME` is what every path in the kernel hangs off — config,
-     * sessions, the remote state directory its token file lands in — so pointing
-     * it at app storage is what keeps a phone's Reasonix separate from anything
-     * else and away from global storage entirely.
-     */
-    private fun prepareHome() {
-        File(home, "remote").mkdirs()
-        // The workspace directory not existing yet is what marks the first run
-        // after this build split it from the kernel's home. That is the one
-        // moment a migration is due, and doing it here means it happens before
-        // the kernel is asked for anything.
-        val firstSplit = !workspaceDir.exists()
-        workspaceDir.mkdirs()
-        if (firstSplit) {
-            adoptSessionsFromHome()
-        }
-        // Every launch, not only the first. The rewrite is cheap and
-        // idempotent, and an entry that survived the first pass would otherwise
-        // survive forever: `firstSplit` is spent the moment the directory
-        // exists, so a build that cleaned the list once and missed leaves the
-        // home on the sidebar for good. Running it unconditionally costs one
-        // small read and makes the whole thing self-correcting.
-        forgetHomeFromWorkspaceList()
-    }
-
-    /**
-     * Drop the kernel's own home from the sidebar's remembered projects.
-     *
-     * The list is written whenever a pane opens, and until this build the pane
-     * opened on the home itself — so an upgraded install carries a "project"
-     * that is really the kernel's own directory. Leaving it there would put the
-     * person back where they started: one tap on it and the workbench is full
-     * of `config.toml`, `cache/` and `projects/` again, which is the complaint
-     * this whole change answers. Only that one path is removed; every folder
-     * someone added on purpose stays.
-     *
-     * Parsed rather than pattern-matched, because the file's two shapes — a bare
-     * array of paths and an object with `paths` and `launch` — both have to keep
-     * whatever else they hold.
-     */
-    private fun forgetHomeFromWorkspaceList() {
-        val file = File(home, "serve-workspaces.json")
-        if (!file.isFile) return
-        val text = runCatching { file.readText() }.getOrNull() ?: return
-        val wrong = runCatching { homeNames() }.getOrNull() ?: return
-        val rewritten = runCatching { withoutHome(text, wrong) }.getOrNull() ?: return
-        if (!rewritten.dropped) return
-        runCatching { file.writeText(rewritten.text) }
-            .onSuccess { Log.i(TAG, "dropped the kernel home from the project list") }
-            .onFailure { Log.w(TAG, "could not rewrite the project list: ${it.message}") }
-    }
-
-    /**
-     * Every name of the kernel's home on this device — not just the one this
-     * process happens to write.
-     *
-     * Android shows one directory under two names: `/data/data/<pkg>` and
-     * `/data/user/0/<pkg>` are two mounts of the same tree, the same inode
-     * either way, and which name a path carries depends on how it was written
-     * rather than on where it points. The list is written by the kernel, whose
-     * working directory this shell set from a path it built itself; a lookup
-     * that compared against only one spelling would silently keep the entry
-     * this exists to remove. Both names are compared, so either spelling is
-     * recognised.
-     */
-    private fun homeNames(): Set<String> {
-        val path = home.absolutePath
-        val names = mutableSetOf(path)
-        val user = "/data/user/0/"
-        val data = "/data/data/"
-        when {
-            path.startsWith(user) -> names.add(data + path.removePrefix(user))
-            path.startsWith(data) -> names.add(user + path.removePrefix(data))
-        }
-        return names
-    }
-
-    /** What a rewrite produced, and whether it actually removed anything. */
-    private class Rewrite(val text: String, val dropped: Boolean)
-
-    /**
-     * The list without the home, in whichever shape it arrived, and whether
-     * anything was actually dropped from it.
-     *
-     * The flag matters because `JSONObject` re-serialises: it escapes every
-     * `/` and does not preserve key order, so a round trip never reproduces
-     * the original bytes. Deciding to write on "the text differs" alone would
-     * therefore rewrite the kernel's file on every single launch, log a drop
-     * that never happened, and race the kernel for a file it also writes.
-     */
-    private fun withoutHome(text: String, wrong: Set<String>): Rewrite {
-        if (text.trimStart().startsWith("[")) {
-            val paths = JSONArray(text)
-            val kept = JSONArray()
-            var dropped = false
-            for (i in 0 until paths.length()) {
-                val path = paths.optString(i)
-                if (path in wrong) {
-                    dropped = true
-                    continue
-                }
-                kept.put(path)
-            }
-            return if (dropped) Rewrite(kept.toString(), true) else Rewrite(text, false)
-        }
-        val list = JSONObject(text)
-        val kept = JSONArray()
-        var dropped = false
-        val paths = list.optJSONArray("paths")
-        if (paths != null) {
-            for (i in 0 until paths.length()) {
-                val path = paths.optString(i)
-                if (path in wrong) {
-                    dropped = true
-                    continue
-                }
-                kept.put(path)
-            }
-            if (dropped) list.put("paths", kept)
-        }
-        if (list.optString("launch") in wrong) {
-            list.remove("launch")
-            dropped = true
-        }
-        return if (dropped) Rewrite(list.toString(), true) else Rewrite(text, false)
-    }
-
-    /**
-     * Move the conversations that were filed under the kernel's own home.
-     *
-     * The transcript store is keyed by the workspace root — one directory per
-     * project, under `<state>/projects/<slug>/sessions` — and until this build
-     * the root was the home itself. Splitting the two therefore moves every
-     * existing conversation to a slug nothing looks under, which reads as "my
-     * history is gone" rather than as a reorganisation. So the old directory is
-     * renamed onto the new slug once.
-     *
-     * Renaming the project directory rather than just `sessions/` carries the
-     * rest of it too: `memory/` is filed the same way, and a project's memory
-     * lost while its transcripts were kept would be a stranger failure than
-     * either alone.
-     *
-     * The slug is the absolute path with its separators flattened, which is
-     * what `config.WorkspaceSlug` does on the kernel's side. Only the home's own
-     * slug is touched: a slug for some other folder is left exactly where it is,
-     * because those are projects someone added on purpose.
-     */
-    private fun adoptSessionsFromHome() {
-        val projects = File(home, "projects")
-        if (!projects.isDirectory) return
-        val from = projects.resolve(slugOf(home.absolutePath))
-        if (!from.isDirectory) return
-        val to = projects.resolve(slugOf(workspaceDir.absolutePath))
-        // A target already there means a previous run half-finished, or the
-        // person opened this folder before. Either way its contents win:
-        // merging two transcript directories is not a thing this can do safely,
-        // and the old one is still on disk to be looked at.
-        if (to.exists()) {
-            Log.i(TAG, "${to.name} already exists; leaving ${from.name} in place")
-            return
-        }
-        if (!from.renameTo(to)) {
-            Log.w(TAG, "could not move ${from.name} to ${to.name}; history stays under the old slug")
-        } else {
-            Log.i(TAG, "moved conversations from ${from.name} to ${to.name}")
-        }
-    }
-
-    /** The kernel's `config.WorkspaceSlug`, for the two paths that matter here. */
-    private fun slugOf(path: String): String = path.replace('/', '-').replace('\\', '-').replace(':', '-')
-
-    /**
-     * The launch credential.
-     *
-     * Minted here rather than read from configuration: a credential a person can
-     * set is one anything that can read their files can present. 32 bytes, hex,
-     * the same shape the desktop host mints.
-     */
-    private fun mintToken(): String {
-        val bytes = ByteArray(32)
-        SecureRandom().nextBytes(bytes)
-        val token = bytes.joinToString("") { "%02x".format(it) }
-        tokenFile.parentFile?.mkdirs()
-        tokenFile.writeText("$token\n")
-        // 0600 by intent, and the app's own private directory means it is
-        // already unreachable to every other app on the device.
-        runCatching {
-            tokenFile.setReadable(false, false)
-            tokenFile.setReadable(true, true)
-            tokenFile.setWritable(false, false)
-            tokenFile.setWritable(true, true)
-        }
-        return token
-    }
-
-    /**
-     * Start the child.
-     *
-     * `--addr 127.0.0.1:0` lets the kernel pick a free port; `--port-file`
-     * makes it announce which. `--auth token` is the mode a phone needs: the
-     * page authenticates, and a state-changing request without the credential
-     * is refused. `--no-open` is belt and braces — a serve never opens a
-     * browser, and a phone has no browser to open.
-     */
-    private fun launch(binary: File, token: String): Process {
-        portFile.delete()
-        pidFile.delete()
-        // The folder the agent works in, resolved before the command line is
-        // built so it can be named on it. See the note under the environment
-        // block for why naming it is not the same as setting the directory.
-        val workspace = launchWorkspaceDir()
-        val command = listOf(
-            binary.absolutePath,
-            "serve",
-            "--addr", "127.0.0.1:0",
-            "--auth", "token",
-            "--token-file", tokenFile.absolutePath,
-            "--port-file", portFile.absolutePath,
-            "--pid-file", pidFile.absolutePath,
-            "--no-open",
-            "-page", pageDir.absolutePath,
-            // The project root, said outright. Without this the kernel derives
-            // it from its working directory, and on this phone the two did not
-            // agree: the sidebar named the shared folder, `write_roots` confined
-            // the file tools to the app's own directory, and every write into the
-            // folder the person was looking at came back
-            // `workspace.write_outside_scope`. A flag is a fact the kernel was
-            // told rather than one it inferred from a mount it sees differently.
-            "--dir", workspace.absolutePath,
-        )
-        val builder = ProcessBuilder(command)
-        builder.environment().apply {
-            put("REASONIX_HOME", home.absolutePath)
-            put("HOME", home.absolutePath)
-            // The kernel's own language, for its tool failures, approval
-            // prompts and error sentences. Without this it detects from the
-            // POSIX locale variables, and Android sets none of them for an
-            // app: the kernel then answers in English while the page in front
-            // of the person is Chinese, and every sentence added for a Chinese
-            // reader was dead text. The tag, not the bare language, so a
-            // Traditional Chinese device resolves to zh-TW rather than zh.
-            // An explicit `language` in the kernel's config.toml still wins:
-            // DetectLanguage applies the configured value over this.
-            val languageTag = Locale.getDefault().toLanguageTag()
-            if (languageTag.isNotBlank() && languageTag != "und") {
-                put("REASONIX_LANG", languageTag)
-            }
-            // Android has no /tmp. Everything that wants a scratch directory —
-            // the shell tool, tool output spooling, sqlite journals — reads this.
-            put("TMPDIR", context.cacheDir.absolutePath)
-            // The phone's own DNS servers. A CGO-free Go binary cannot read them
-            // for itself — Android keeps them in `netd`, and Go looks for a
-            // `/etc/resolv.conf` that does not exist — so without this the kernel
-            // resolves nothing and every provider probe reports "连接失败" on a
-            // device whose browser reaches the same address fine.
-            val dns = Dns.servers(context)
-            if (dns.isNotBlank()) {
-                put("REASONIX_DNS", dns)
-                Log.i(TAG, "kernel DNS: $dns (${Dns.describe(context)})")
-                if (Dns.looksLikeDot(dns)) {
-                    // Private DNS (DNS-over-TLS) is on, and it hands back a
-                    // hostname this kernel cannot resolve by definition. Saying
-                    // so here is what turns "连不上" into something actionable.
-                    Log.w(TAG, "kernel DNS looks like a private-DNS hostname; turn private DNS off or set it to automatic")
-                }
-            } else {
-                Log.w(TAG, "kernel DNS: none reported by the system")
-            }
-            // The shell's browser server, when one is listening. The kernel
-            // reads this to bind its browser tools to the shell's WebView
-            // instead of looking for a Chromium binary that does not exist on
-            // a phone. When absent (zero), the variable is not set and the
-            // kernel keeps the browser tools suspended — the correct
-            // degradation for a phone with no engine to drive.
-            val shellPort = browserShellPort
-            if (shellPort > 0) {
-                put("REASONIX_SHELL_BROWSER_PORT", shellPort.toString())
-                // The credential the server checks. Set only alongside the
-                // port: a token with nothing listening would be a variable the
-                // kernel carries for no reason.
-                val shellToken = browserShellToken
-                if (shellToken.isNotBlank()) {
-                    put("REASONIX_SHELL_BROWSER_TOKEN", shellToken)
-                }
-            }
-        }
-        // The agent's folder, not the kernel's. `REASONIX_HOME` above is still
-        // where the config, the sessions and the transcripts live; this is what
-        // the workspace root resolves to, because the kernel reads the working
-        // directory for it.
-        //
-        // The folder the person last opened, when it is still usable — the same
-        // answer the desktop host gives (`launchWorkspace`), and the reason a
-        // phone session used to work in the app's own `files/workspace` while
-        // the sidebar said it was in the shared folder: the launch entry in
-        // `serve-workspaces.json` was written and then ignored, and `write_roots`
-        // is derived from the working directory, so the file tools were confined
-        // to the app's private folder and every write into the shared one was
-        // refused. `workspaceDir` is still the answer for a first run and for a
-        // folder since deleted, but the choice is never silent — see
-        // [launchWorkspaceDir]. `workspace` was resolved above so it could also
-        // be named on the command line.
-        builder.directory(workspace)
-        // `PWD` is what the kernel's own `os.Getwd` prefers: Go uses it whenever
-        // it names the same directory as `.`, which is exactly this case, and it
-        // is the only way to make the kernel resolve its root to the string this
-        // shell chose. Without it `os.Getwd` falls back to the kernel's view of
-        // the mount, and on Android `/storage/emulated/0/...` and the path the
-        // FUSE layer reports for it need not be spelled the same way. The kernel
-        // derives `write_roots` from that root, so the two spellings have to be
-        // the same one.
-        builder.environment().put("PWD", workspace.absolutePath)
-        builder.redirectErrorStream(true)
-        val process = builder.start()
-
-        // The kernel's own log is the only place a startup failure says why, and
-        // a phone has no terminal to read. It is drained on a thread and kept
-        // ring-buffered so the About screen can show the last of it.
-        Thread({ drain(process) }, "kernel-log").apply { isDaemon = true }.start()
-        return process
-    }
-
-    /**
-     * The folder the person last opened, or null when there is not one.
-     *
-     * `serve-workspaces.json` is the kernel's own record of the projects the
-     * sidebar lists, and its `launch` entry is which of them a session starts
-     * in. Both shapes the file has are read — a bare array of paths, and an
-     * object with `paths` and `launch` — because both are written in the wild
-     * and a reader that only knew one would silently fall back.
-     *
-     * The entry has to be one of the listed paths, which is the same rule the
-     * kernel applies when it reads this file (`workspacelist.Read` blanks a
-     * `launch` that is not in `paths`). It matters more here than there: the
-     * working directory decides `write_roots`, so whatever this answers is
-     * where the agent's file tools may write — and on a phone that permission
-     * reaches all of shared storage. A file with a `launch` outside its own
-     * list is one this shell did not write, and it gets the listed answer.
-     *
-     * Null for anything unusable: no file, unreadable JSON, a launch that is
-     * not among the listed folders, an entry that has since been deleted, or a
-     * path that is now a file. Every one of those means the same thing to the
-     * caller — start where this shell always started.
-     */
-    private fun rememberedLaunchDir(): File? {
-        val file = File(home, "serve-workspaces.json")
-        if (!file.isFile) return null
-        val text = runCatching { file.readText() }.getOrNull() ?: return null
-        val launch = runCatching {
-            // A bare array is the file's other shape — the one older kernels
-            // wrote, and therefore the one a person upgrading is most likely to
-            // have. Without this branch `JSONObject(text)` throws on it and the
-            // whole function falls back, which is the same mismatch (the
-            // sidebar naming one folder, the session working in another) this
-            // exists to fix. `withoutHome` below reads both shapes the same way.
-            if (text.trimStart().startsWith("[")) {
-                val arr = JSONArray(text)
-                if (arr.length() == 0) return@runCatching null
-                arr.optString(0)
-            } else {
-                val json = JSONObject(text)
-                val paths = json.optJSONArray("paths")
-                    ?.let { arr -> (0 until arr.length()).mapNotNull { arr.optString(it).takeIf(String::isNotBlank) } }
-                    .orEmpty()
-                if (paths.isEmpty()) return@runCatching null
-                json.optString("launch").takeIf { it.isNotBlank() && it in paths } ?: paths.first()
-            }
-        }.getOrNull()?.takeIf { it.isNotBlank() } ?: return null
-        val dir = runCatching { File(launch) }.getOrNull() ?: return null
-        if (!dir.isDirectory) {
-            // A launch entry this process cannot stat is exactly the failure the
-            // caller exists to avoid, and falling back silently is what made it
-            // take three releases to notice: the session opened in the app's own
-            // folder while the sidebar named the shared one. A phone has no
-            // terminal, so the log is the only place the reason can be said —
-            // and `exists`/`readable` tell apart "deleted" from "not permitted",
-            // which need different answers from the person.
-            Log.w(
-                TAG,
-                "launch entry $launch is not a usable directory " +
-                    "(exists=${dir.exists()}, readable=${dir.canRead()})",
-            )
-            return null
-        }
-        return dir
-    }
-
-    /**
-     * The folder the kernel should start in.
-     *
-     * Either the launch entry — the folder the person last opened, which is
-     * also the one the sidebar shows — or the app's own folder when there is
-     * none. Whichever it is, it is logged, because the two disagreeing is the
-     * bug this exists to fix and a silent choice is what let it survive.
-     */
-    private fun launchWorkspaceDir(): File {
-        val remembered = rememberedLaunchDir()
-        if (remembered != null) {
-            Log.i(TAG, "kernel workspace: ${remembered.absolutePath} (the remembered launch project)")
-            return remembered
-        }
-        Log.i(TAG, "kernel workspace: ${workspaceDir.absolutePath} (no remembered launch project)")
-        return workspaceDir
-    }
-
-    private val logLines = ArrayDeque<String>()
-
-    private fun drain(process: Process) {
-        runCatching {
-            process.inputStream.bufferedReader().useLines { lines ->
-                lines.forEach { line ->
-                    Log.i(TAG, line)
-                    synchronized(logLines) {
-                        logLines.addLast(line)
-                        while (logLines.size > LOG_KEEP) logLines.removeFirst()
-                    }
-                }
-            }
-        }
-    }
-
-    /** The kernel's tail, newest last, for a bug report or the About screen. */
-    fun recentLog(): String = synchronized(logLines) { logLines.joinToString("\n") }
-
-    private fun awaitPort(process: Process): String {
-        val deadline = System.currentTimeMillis() + START_TIMEOUT_MS
-        while (System.currentTimeMillis() < deadline) {
-            if (!process.isAlive) {
-                throw IllegalStateException("内核启动即退出。\n${recentLog().takeLast(2000)}")
-            }
-            val text = if (portFile.isFile) runCatching { portFile.readText().trim() }.getOrNull() else null
-            // The file is written by the kernel on the way to serving, and the
-            // kernel rewrites it with the real port when it was given :0.
-            if (!text.isNullOrBlank() && text.contains(":")) return text
-            Thread.sleep(POLL_MS)
-        }
-        throw IllegalStateException("内核在 ${START_TIMEOUT_MS / 1000}s 内没有报告监听地址。\n${recentLog().takeLast(2000)}")
-    }
-
-    /**
-     * Wait until the bound port answers.
-     *
-     * A port that is open but not yet serving is the normal first second of a
-     * kernel's life; a WebView pointed at it would show a connection error and
-     * cache the failure, so the wait belongs here rather than in the page.
-     */
-    private fun awaitServing(process: Process, origin: String) {
-        val deadline = System.currentTimeMillis() + START_TIMEOUT_MS
-        while (System.currentTimeMillis() < deadline) {
-            if (!process.isAlive) {
-                throw IllegalStateException("内核在开始服务前退出。\n${recentLog().takeLast(2000)}")
-            }
-            if (probe("$origin/")) return
-            Thread.sleep(POLL_MS)
-        }
-        throw IllegalStateException("内核已监听 $origin，但页面没有响应。\n${recentLog().takeLast(2000)}")
-    }
-
-    private fun probe(url: String): Boolean = runCatching {
-        (URL(url).openConnection() as HttpURLConnection).run {
-            connectTimeout = 1000
-            readTimeout = 1000
-            requestMethod = "GET"
-            try {
-                responseCode in 200..399
-            } finally {
-                disconnect()
-            }
-        }
-    }.getOrDefault(false)
-
-    private companion object {
-        const val TAG = "ReasonixKernel"
-        const val LOG_KEEP = 400
-        const val POLL_MS = 120L
-        const val START_TIMEOUT_MS = 30_000L
-    }
-}

android/app/src/main/java/io/reasonix/mobile/app/KernelService.kt

@@ -1,139 +0,0 @@
-package io.reasonix.mobile.app
-
-import android.Manifest
-import android.app.Notification
-import android.app.PendingIntent
-import android.app.Service
-import android.content.Context
-import android.content.Intent
-import android.content.pm.PackageManager
-import android.content.pm.ServiceInfo
-import android.os.Build
-import android.os.IBinder
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
-import androidx.core.app.ServiceCompat
-import androidx.core.content.ContextCompat
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.launch
-
-/**
- * Keeps the kernel alive while the app is not on screen.
- *
- * The reason this exists at all: an agent turn that takes minutes is a normal
- * turn, and Android reclaims a backgrounded app's child process within seconds
- * of the screen going off. Without the service, pocketing the phone would kill
- * a running task — the one failure mode that makes a phone a bad client for
- * something that works on its own.
- *
- * A foreground service needs a notification the person can see, which is also
- * the honest thing to show: the kernel is running and what it is doing lives on
- * another machine.
- */
-class KernelService : Service() {
-
-    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
-
-    override fun onBind(intent: Intent?): IBinder? = null
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        // Promoted before `start()`: a service that starts work first and
-        // notifies after has a window in which the system may kill it, and the
-        // work it would have been protecting is exactly what is being started.
-        startForegroundNotification()
-
-        val kernel = (application as App).kernel
-        scope.launch {
-            kernel.start().onFailure { failure ->
-                // A kernel that will not start is a fact the person needs, and a
-                // notification that only ever said "running" would be a lie.
-                notify(SERVICE_NOTICE, getString(R.string.notify_failed_title), failure.message.orEmpty())
-                stopSelf()
-            }
-        }
-        // Sticky, so a kernel killed under memory pressure comes back when there
-        // is room — which is what a person who left a task running expects.
-        return START_STICKY
-    }
-
-    override fun onDestroy() {
-        scope.cancel()
-        super.onDestroy()
-    }
-
-    private fun startForegroundNotification() {
-        val notification = buildNotification(
-            getString(R.string.notify_running_title),
-            getString(R.string.notify_running_body),
-        )
-        // `dataSync` matches the manifest's declaration. On 34+ the type is
-        // mandatory and a mismatch throws, so it is named in both places.
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            ServiceCompat.startForeground(
-                this,
-                SERVICE_NOTICE,
-                notification,
-                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
-            )
-        } else {
-            startForeground(SERVICE_NOTICE, notification)
-        }
-    }
-
-    private fun buildNotification(title: String, body: String): Notification {
-        val open = PendingIntent.getActivity(
-            this,
-            0,
-            Intent(this, MainActivity::class.java).apply {
-                flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
-            },
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
-        )
-        return NotificationCompat.Builder(this, App.CHANNEL_KERNEL)
-            .setSmallIcon(R.drawable.ic_notification)
-            .setContentTitle(title)
-            .setContentText(body)
-            .setContentIntent(open)
-            // The notification is a receipt, not an alarm; swiping it away
-            // leaves the kernel running, which is what the person meant by
-            // swiping it.
-            .setOngoing(false)
-            .setSilent(true)
-            .setPriority(NotificationCompat.PRIORITY_MIN)
-            .build()
-    }
-
-    private fun notify(id: Int, title: String, body: String) {
-        // The notification permission is granted at runtime from Android 13 and
-        // the person can refuse it. Without this check the call throws
-        // SecurityException and takes the service down with it — the opposite of
-        // what a notification that could not be shown should do. Below 13 the
-        // permission does not exist and posting always succeeds.
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
-            ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) !=
-            PackageManager.PERMISSION_GRANTED
-        ) {
-            return
-        }
-        runCatching {
-            NotificationManagerCompat.from(this).notify(id, buildNotification(title, body))
-        }
-    }
-
-    companion object {
-        private const val SERVICE_NOTICE = 1
-
-        /** Idempotent: called on every start of the activity, and by the boot
-         *  path, and safe to repeat. */
-        fun start(context: Context) {
-            ContextCompat.startForegroundService(context, Intent(context, KernelService::class.java))
-        }
-
-        fun stop(context: Context) {
-            context.stopService(Intent(context, KernelService::class.java))
-        }
-    }
-}

android/app/src/main/java/io/reasonix/mobile/app/NativeBridge.kt

@@ -1,744 +0,0 @@
-package io.reasonix.mobile.app
-
-import android.content.ClipData
-import android.content.ClipboardManager
-import android.content.ContentValues
-import android.content.Context
-import android.content.res.Configuration
-import android.net.Uri
-import android.os.Build
-import android.os.Environment
-import android.os.Handler
-import android.os.Looper
-import android.provider.MediaStore
-import android.webkit.JavascriptInterface
-import android.webkit.MimeTypeMap
-import java.io.File
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.atomic.AtomicReference
-
-/**
- * What the page can ask the phone for.
- *
- * This is the whole surface, and it is deliberately tiny. Android's
- * `@JavascriptInterface` is a bridge into the app's process from a WebView whose
- * content is a web page: every method here is reachable by anything that can run
- * script in that page, so each one is written as a verb with no address
- * parameter it does not need, and none of them can name a path outside the
- * kernel's own home.
- *
- * It is deliberately *not* the Electron preload bridge. That one exposes window
- * management, a filesystem walker, an editor launcher and a browser view host —
- * all of which are meaningless on a phone, and the two that were not (open a URL,
- * save a file) already have a way to happen here: `WebViewClient` routes external
- * links to the browser, and the page's own download reaches the WebView's
- * `DownloadListener`.
- *
- * The one thing a phone must add is `importIntoHome`: the kernel runs on this
- * device and can only read paths under its own home, so a private key the person
- * has in their Documents folder has to be copied across. Nothing else the page
- * wants is out of its reach.
- */
-class NativeBridge(
-    private val context: Context,
-    private val kernel: Kernel,
-    private val onOpen: (String) -> Unit,
-) {
-
-    /**
-     * Whether the document calling may use this bridge.
-     *
-     * `addJavascriptInterface` makes the object reachable from whatever page the
-     * WebView holds, so a link the model produced — or a cleartext page on the
-     * LAN — would otherwise get `importIntoHome`, `pickFolder`, `hostCall` and
-     * the clipboard. The activity answers by comparing the main frame's origin
-     * against the kernel's and the one paired computer the person confirmed.
-     *
-     * Anything that reaches the device checks this first. The five methods that
-     * do not — version, systemTheme, safeArea, setLayerOpen, setRunning — report
-     * back what the page already knows about its own window and grant nothing.
-     */
-    var trusted: () -> Boolean = { false }
-
-    /** The version the page reads to decide whether this bridge is the one it
-     *  knows. Bumped when a method's contract changes, not when one is added. */
-    @JavascriptInterface
-    fun version(): String = BRIDGE_VERSION
-
-    /**
-     * Copy a file the person picks into the kernel's home, answering with its
-     * path there — or "" when they dismissed the picker.
-     *
-     * `kind` names the directory inside the home, because that is a fact about
-     * the kernel's layout and not about the file: an SSH private key belongs in
-     * `.ssh`, and a dotenv the kernel reads for passphrases belongs at the root
-     * of the home where `config.Load` looks for it.
-     *
-     * The path that comes back is *inside the home*, never the document
-     * provider's URI. That is the point: the kernel is a child process with no
-     * access to the provider, so a `content://` would be a path it cannot open.
-     */
-    @JavascriptInterface
-    fun importIntoHome(kind: String, name: String): String {
-        if (!trusted()) return ""
-        val dir = when (kind) {
-            "identity" -> File(kernel.homeDir(), ".ssh")
-            "env" -> kernel.homeDir()
-            else -> return ""
-        }
-        val safeName = sanitise(name)
-        if (safeName.isEmpty()) return ""
-
-        val picked = pickFile() ?: return ""
-        return try {
-            dir.mkdirs()
-            val target = File(dir, safeName)
-            context.contentResolver.openInputStream(picked)?.use { input ->
-                target.outputStream().use { output -> input.copyTo(output) }
-            } ?: return ""
-            // A private key with group or world read is one OpenSSH refuses to
-            // use, and the refusal reads as "bad permissions" from a long way
-            // away. Setting it here is what makes the file usable at all.
-            if (kind == "identity") {
-                runCatching {
-                    target.setReadable(false, false)
-                    target.setReadable(true, true)
-                    target.setWritable(false, false)
-                    target.setWritable(true, true)
-                }
-            }
-            target.absolutePath
-        } catch (_: Exception) {
-            // A copy that failed leaves nothing behind; the caller sees "" and
-            // the person can try again.
-            ""
-        }
-    }
-
-    /**
-     * Open a URL in the device's browser.
-     *
-     * The page asks for this when a link points somewhere outside the kernel —
-     * a provider's console, a documentation page — and loading it in place would
-     * strand the person in a window with no address bar and no way back.
-     */
-    @JavascriptInterface
-    fun openExternal(url: String) {
-        if (!trusted()) return
-        // Only what a browser can open. A `file://` or `content://` here would
-        // be the page reaching into the device through a method named for
-        // leaving it.
-        if (!url.startsWith("http://") && !url.startsWith("https://")) return
-        onOpen(url)
-    }
-
-    /** Put text on the clipboard. A WebView's own `navigator.clipboard` write is
-     *  gated behind a permission Android grants only to a focused document, so
-     *  the one thing the page actually offers to copy — a token, a command, a
-     *  path — has no other way out.
-     *
-     *  Answers whether the write landed. A platform that refuses it raises
-     *  rather than answering, and an exception must not cross
-     *  `@JavascriptInterface` as a silent success — the page would say 已复制
-     *  over an empty clipboard. Caught here, the answer is the one the caller
-     *  can act on: false, and the button says 复制失败 instead. */
-    @JavascriptInterface
-    fun copyText(text: String): Boolean = if (!trusted()) false else runCatching {
-        val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
-        clipboard.setPrimaryClip(ClipData.newPlainText("reasonix", text))
-    }.isSuccess
-
-    /**
-     * Write text where the person picks, and answer with the path it went to.
-     *
-     * The page's own route to a file — a blob URL on an `<a download>` — reaches
-     * nothing here: a WebView has no downloads shelf, and its `DownloadListener`
-     * fires only for a real navigation, not for a blob the page just built. So
-     * the text crosses the bridge and the shell opens the system's document
-     * picker, which is also the only way to reach a folder the person can find
-     * again afterwards.
-     *
-     * "" is a dismissal, the same answer `importIntoHome` gives, and the page
-     * reads the two the same way.
-     */
-    /**
-     * Put a copy of a file where a phone's own file manager will show it.
-     *
-     * `saveText` asks the person where to put it, which is the right question
-     * on a desktop and the wrong one here: the kernel's workspace is
-     * app-private storage, so the file someone wants is in a place no file
-     * manager can open, and a picker that starts at "recent" is another place
-     * to lose it. This answers the actual question — "where is it" — by
-     * putting it in Downloads, in a folder named after the app, under a name
-     * that is the file's own.
-     *
-     * The answer is the path relative to shared storage, so the page can say
-     * where the file went rather than only that it worked. "" means the write
-     * failed or the platform refused it.
-     *
-     * MediaStore on Android 10 and later, a plain file before that. The two
-     * are not interchangeable: from 10 the app may not write another app's
-     * files directly, and MediaStore is the only way in; before it there is no
-     * MediaStore collection for downloads and the public directory is writable
-     * with the storage permission this app does not ask for, so that branch is
-     * best-effort and says so by answering "".
-     */
-    @JavascriptInterface
-    fun exportToDownloads(name: String, content: String): String {
-        if (!trusted()) return ""
-        val safeName = sanitise(name).ifEmpty { "reasonix.txt" }
-        return exportFile(safeName, content).orEmpty()
-    }
-
-    @JavascriptInterface
-    fun saveText(name: String, content: String): String {
-        if (!trusted()) return ""
-        val safeName = sanitise(name).ifEmpty { "reasonix.txt" }
-        return saveFile(safeName, content) ?: ""
-    }
-
-    /**
-     * Hand text to whatever the device shares with — a chat app, the mail
-     * client, a note app.
-     *
-     * The share sheet rather than a second save dialog: "where is that file"
-     * is the question this answers, and on a phone a document someone wants to
-     * keep or send usually goes through one of those apps rather than a folder.
-     *
-     * Shared as text with the filename as its subject, which is what every
-     * target understands. A file attachment would need a `FileProvider` and a
-     * cache copy for the same words to arrive.
-     */
-    @JavascriptInterface
-    fun shareText(name: String, content: String): Boolean {
-        if (!trusted()) return false
-        val safeName = sanitise(name).ifEmpty { "reasonix.txt" }
-        val posted = java.util.concurrent.CountDownLatch(1)
-        var ok = false
-        main.post {
-            ok = runCatching { askForShare(safeName, content) }.getOrDefault(false)
-            posted.countDown()
-        }
-        runCatching { posted.await(SHARE_TIMEOUT_SECONDS, TimeUnit.SECONDS) }
-        return ok
-    }
-
-    /**
-     * The device's own light/dark answer.
-     *
-     * The page resolves its theme from `localStorage` first and only asks the
-     * system when nothing is saved, so this is what makes a fresh install match
-     * the phone instead of defaulting to light.
-     */
-    @JavascriptInterface
-    fun systemTheme(): String {
-        val night = context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
-        return if (night == Configuration.UI_MODE_NIGHT_YES) "dark" else "light"
-    }
-
-    /**
-     * The window's real safe-area insets, in CSS pixels, as
-     * `top,right,bottom,left`.
-     *
-     * A WebView does not implement `env(safe-area-inset-*)`: those are an iOS
-     * Safari feature, and on Android every one of them resolves to `0`. So a
-     * page that pads itself with them — which `mobile.css` does — is un-padded
-     * on exactly the platform this shell exists for, and the first line of the
-     * interface sits under the status bar.
-     *
-     * The values have to come from here for a second reason too: from Android 15
-     * the window is edge-to-edge whether the app asks for it or not, so the bars
-     * really are drawn over the page and there is no window-manager switch that
-     * could move the content back down.
-     *
-     * Answered as a string because that is what crosses the bridge; the page
-     * sets it as a CSS custom property and `mobile.css` reads it.
-     */
-    @JavascriptInterface
-    fun safeArea(): String {
-        val insets = onInsets?.invoke() ?: return "0,0,0,0"
-        return "${insets.left},${insets.top},${insets.right},${insets.bottom}"
-    }
-
-    /**
-     * Read the pairing code a computer is showing.
-     *
-     * A phone cannot type what a computer renders as a QR code — it is a
-     * one-time code inside a URL, and the whole reason it is a picture is that
-     * nobody reads one aloud. So the page asks for the camera and gets the text
-     * back, which is the same direction the computer's own dialog describes.
-     *
-     * The answer is the code's own text, not a parsed result: what a pairing
-     * fragment means is the page's to decide, and it already knows how — the
-     * `#pair=` handling ships with the interface.
-     */
-    @JavascriptInterface
-    fun scanPairingCode(): String = if (!trusted()) "" else scanWithCamera()
-
-    /**
-     * Load a URL in this window instead of handing it to the browser.
-     *
-     * The page asks for this once, right after a scan: the code it read points at
-     * the computer's own Studio, and the whole point of scanning is to end up
-     * looking at that computer. Going out to a browser would leave the app on one
-     * screen and the paired machine on another, with the back gesture an exit
-     * rather than a return.
-     *
-     * Only http and https are accepted. The page is this repository's own build
-     * and is trusted, but a scanner reads whatever is held in front of it, so the
-     * one value that arrives here from outside is checked: a `file://` or
-     * `javascript:` that happened to be on a printed code must not become a
-     * navigation.
-     */
-    @JavascriptInterface
-    fun openInApp(url: String) {
-        if (!trusted()) return
-        val trimmed = url.trim()
-        if (!trimmed.startsWith("http://") && !trimmed.startsWith("https://")) return
-        main.post { onOpenInApp?.invoke(trimmed) }
-    }
-
-    /** How the activity loads a URL in the window it owns. Set by the activity. */
-    var onOpenInApp: ((String) -> Unit)? = null
-
-    // ---- the native browser view host bridge ----
-    //
-    // The page's `host.ts` looks for `window.reasonixHost` with Promise-based
-    // methods (showBrowserView, hideBrowserView, etc.). `@JavascriptInterface`
-    // is synchronous, so the round trip is: JS generates an id, calls
-    // `hostCall(id, method, args)`, Kotlin does the work asynchronously, then
-    // pushes the result back via `evaluateJavascript` calling
-    // `window.__reasonixHostReply(id, json)`. The injected script (in
-    // MainActivity) wires each Promise to that reply channel.
-
-    /** How the activity handles an async host call. Set by the activity. */
-    var onHostCall: ((id: String, method: String, args: String) -> Unit)? = null
-
-    /**
-     * Entry point for the page's `window.reasonixHost` Promise methods.
-     *
-     * `id` is a unique call identifier the JS side generated; `method` is the
-     * method name (e.g. "showBrowserView"); `args` is the JSON-encoded argument
-     * array. The activity handles the call asynchronously and replies through
-     * `evaluateJavascript` with `window.__reasonixHostReply(id, resultJson)`.
-     */
-    @JavascriptInterface
-    fun hostCall(id: String, method: String, args: String) {
-        if (!trusted()) return
-        onHostCall?.invoke(id, method, args)
-    }
-
-    /**
-     * Whether the page has a panel up that the back gesture should close first.
-     *
-     * Written by the page, read by the activity's back handler. The page owns the
-     * answer — it is the only thing that knows what is open, and a second
-     * implementation of that question in the shell would be one that drifts — so
-     * the page reports the fact and the shell keeps the action.
-     *
-     * Volatile because the two ends are on different threads: the page sets it
-     * from the WebView's JavaScript thread, the back gesture reads it on the main
-     * one, and a stale read here is a panel that does not close.
-     */
-    @Volatile
-    var layerOpen: Boolean = false
-        private set
-
-    @JavascriptInterface
-    fun setLayerOpen(open: Boolean) {
-        layerOpen = open
-    }
-
-    // ---- the picker, which is an Activity result in a synchronous world ----
-
-    private val pending = AtomicReference<Uri?>(null)
-    private val latch = AtomicReference<CountDownLatch?>(null)
-
-    /** The code the camera read, held between the activity's answer and the
-     *  wait below — the same round trip the file picker takes. */
-    private val scanned = AtomicReference<String?>(null)
-    private val scanLatch = AtomicReference<CountDownLatch?>(null)
-
-    /** The main thread, because starting an Activity result must happen there. */
-    private val main = Handler(Looper.getMainLooper())
-
-    /**
-     * How to ask for a file. Set by the activity, which owns the Activity Result
-     * API; it answers whether the ask was dispatched, not whether the person
-     * picked anything — that arrives through `deliver`.
-     */
-    var askForFile: () -> Boolean = { false }
-
-    /**
-     * How the activity reports the window's insets. Set by the activity, which is
-     * the only thing that can see them, and asked on every call rather than
-     * cached — a rotation, a fold, or the keyboard opening all change them, and a
-     * stale answer here is a stripe of interface under the status bar.
-     */
-    var onInsets: (() -> Insets?)? = null
-
-    /**
-     * How to open the camera. Set by the activity, which owns the Activity
-     * Result API; like `askForFile` it answers whether the ask was dispatched,
-     * and the code itself arrives through `deliverScan`.
-     */
-    var askForScan: () -> Boolean = { false }
-
-    /**
-     * How to put a file where the person picks. Set by the activity, which owns
-     * the Activity Result API; it answers whether the ask was dispatched, and
-     * the chosen place arrives through `deliverSave`.
-     */
-    var askForSave: (name: String, content: String) -> Boolean = { _, _ -> false }
-
-    /**
-     * How to open the share sheet. Set by the activity, which is the only thing
-     * that can start an Intent; it answers whether anything on the device took
-     * the text.
-     */
-    var askForShare: (name: String, content: String) -> Boolean = { _, _ -> false }
-
-    /** The place the save dialog answered with, held between the two halves. */
-    private val saveTarget = AtomicReference<Uri?>(null)
-    private val saveLatch = AtomicReference<CountDownLatch?>(null)
-
-    /**
-     * Ask where to put a file and write it there.
-     *
-     * The same latch round trip as `pickFile`, and for the same reason:
-     * `@JavascriptInterface` cannot suspend, so the WebView's thread waits while
-     * the picker is open — a modal panel the person is looking at.
-     */
-    private fun saveFile(name: String, content: String): String? {
-        val gate = CountDownLatch(1)
-        saveLatch.set(gate)
-        saveTarget.set(null)
-
-        val posted = CountDownLatch(1)
-        var dispatched = false
-        main.post {
-            dispatched = runCatching { askForSave(name, content) }.getOrDefault(false)
-            posted.countDown()
-        }
-        val ready = runCatching { posted.await(PICK_TIMEOUT_SECONDS, TimeUnit.SECONDS) }.getOrDefault(false)
-        if (!ready || !dispatched) {
-            saveLatch.set(null)
-            return null
-        }
-        return try {
-            if (!gate.await(PICK_TIMEOUT_SECONDS, TimeUnit.SECONDS)) null
-            else saveTarget.get()?.toString()
-        } catch (_: InterruptedException) {
-            null
-        } finally {
-            saveLatch.set(null)
-        }
-    }
-
-    /** Called by the activity once the bytes are written. A null uri is a dismissal. */
-    fun deliverSave(uri: Uri?) {
-        saveTarget.set(uri)
-        saveLatch.get()?.countDown()
-    }
-
-    /**
-     * Read the pairing code a computer is showing, and return it.
-     *
-     * The same shape as `pickFile` and for the same reason: a
-     * `@JavascriptInterface` method is called on the WebView's thread and must
-     * return a value, so the camera is opened on the main thread and this one
-     * waits. The block lasts as long as the person is aiming, which is why the
-     * timeout is generous — a scan that gave up after a few seconds would be
-     * one nobody could complete.
-     *
-     * An empty string is "no code", which is what a refusal, a cancellation and
-     * a timeout all are. The caller acts on the text, so a distinct error would
-     * only be a fourth way to say the same thing.
-     */
-    private fun scanWithCamera(): String {
-        val gate = CountDownLatch(1)
-        scanLatch.set(gate)
-        scanned.set(null)
-
-        val posted = CountDownLatch(1)
-        var dispatched = false
-        main.post {
-            dispatched = runCatching { askForScan() }.getOrDefault(false)
-            posted.countDown()
-        }
-        val ready = runCatching { posted.await(SCAN_TIMEOUT_SECONDS, TimeUnit.SECONDS) }.getOrDefault(false)
-        if (!ready || !dispatched) {
-            scanLatch.set(null)
-            return ""
-        }
-        return try {
-            if (!gate.await(SCAN_TIMEOUT_SECONDS, TimeUnit.SECONDS)) "" else scanned.get().orEmpty()
-        } catch (_: InterruptedException) {
-            ""
-        } finally {
-            scanLatch.set(null)
-        }
-    }
-
-    /** Called by the activity when the scanner answers. Null is a dismissal. */
-    fun deliverScan(text: String?) {
-        scanned.set(text)
-        scanLatch.get()?.countDown()
-    }
-
-    /**
-     * Ask for one file and wait for the answer.
-     *
-     * `@JavascriptInterface` methods cannot suspend: the WebView calls them on
-     * its own thread and expects a value back. So the ask is posted to the main
-     * thread and this one waits on a latch. The cost is a blocked JS thread for
-     * as long as the picker is open — which is a modal panel the person is
-     * looking at, with nothing else in the page running.
-     *
-     * A timeout is set rather than waiting forever: a picker that never answers
-     * (the activity destroyed underneath it) would otherwise pin a WebView
-     * thread until the process died.
-     */
-    private fun pickFile(): Uri? {
-        val gate = CountDownLatch(1)
-        latch.set(gate)
-        pending.set(null)
-
-        val posted = CountDownLatch(1)
-        var dispatched = false
-        main.post {
-            dispatched = runCatching { askForFile() }.getOrDefault(false)
-            posted.countDown()
-        }
-        val ready = runCatching { posted.await(PICK_TIMEOUT_SECONDS, TimeUnit.SECONDS) }.getOrDefault(false)
-        if (!ready || !dispatched) {
-            latch.set(null)
-            return null
-        }
-
-        return try {
-            if (!gate.await(PICK_TIMEOUT_SECONDS, TimeUnit.SECONDS)) null else pending.get()
-        } catch (_: InterruptedException) {
-            null
-        } finally {
-            latch.set(null)
-        }
-    }
-
-    /** Called by the activity when the picker answers. A null uri is a dismissal. */
-    fun deliver(uri: Uri?) {
-        pending.set(uri)
-        latch.get()?.countDown()
-    }
-
-    /** The folder under Downloads that this app's exports land in. */
-    private fun exportFolder(): String = "Reasonix"
-
-    /** The MIME type this name declares, or null when the platform does not know
-     *  it.
-     *
-     * Where the type is written, the name and the type agree, and that agreement
-     * is the whole fix: `.md` is answered `text/markdown` here, so MediaStore
-     * has nothing to correct and the export stays `报告.md` instead of being
-     * renamed `报告.md.txt` by the `text/plain` it used to be given. Where the
-     * type is unknown the field is left off, which leaves MediaStore to derive
-     * the same `application/octet-stream` it would have been told — the name
-     * still stands on its own, which is all this is for. */
-    private fun mimeFor(name: String): String? {
-        val ext = name.substringAfterLast('.', "").lowercase()
-        if (ext.isEmpty() || ext == name.lowercase()) return null
-        return runCatching { MimeTypeMap.getSingleton().getMimeTypeFromExtension(ext) }.getOrNull()
-    }
-
-    private fun exportFile(name: String, content: String): String? = runCatching {
-        val bytes = content.toByteArray(Charsets.UTF_8)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            val resolver = context.contentResolver
-            val values = ContentValues().apply {
-                put(MediaStore.Downloads.DISPLAY_NAME, name)
-                // The type is derived here rather than declared, and it is
-                // written only when the name really has an extension that maps
-                // to one.
-                //
-                // It used to be `text/plain` for everything, and MediaStore
-                // answers a name whose extension disagrees with the declared
-                // type by appending its own: exporting `报告.md` landed in
-                // Downloads as `报告.md.txt`, and any source file came out with
-                // the wrong second extension. Deriving the type from the name
-                // instead keeps the two in agreement — which is what stops the
-                // rename — and a name the platform has no type for is left off
-                // entirely rather than declared as `application/octet-stream`,
-                // so nothing is corrected there either.
-                mimeFor(name)?.let { put(MediaStore.Downloads.MIME_TYPE, it) }
-                put(
-                    MediaStore.Downloads.RELATIVE_PATH,
-                    Environment.DIRECTORY_DOWNLOADS + "/" + exportFolder(),
-                )
-                // Hidden until the bytes are all there, so a file manager that
-                // reads the folder mid-write cannot show half a document.
-                put(MediaStore.Downloads.IS_PENDING, 1)
-            }
-            val uri = resolver.insert(MediaStore.Downloads.EXTERNAL_CONTENT_URI, values)
-                ?: return@runCatching null
-            resolver.openOutputStream(uri)?.use { it.write(bytes) } ?: return@runCatching null
-            values.clear()
-            values.put(MediaStore.Downloads.IS_PENDING, 0)
-            resolver.update(uri, values, null, null)
-            "${Environment.DIRECTORY_DOWNLOADS}/${exportFolder()}/$name"
-        } else {
-            val dir = File(
-                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
-                exportFolder(),
-            )
-            if (!dir.exists() && !dir.mkdirs()) return@runCatching null
-            val target = File(dir, name)
-            target.writeBytes(bytes)
-            target.absolutePath
-        }
-    }.getOrNull()
-
-    private fun sanitise(name: String): String {
-        // A name from the page is used as a filename, so it is reduced to one:
-        // no separators, no traversal, and nothing a filesystem treats as
-        // special. The default is the name the field it came from suggests.
-        val trimmed = name.trim().substringAfterLast('/').substringAfterLast('\\')
-        if (trimmed.isEmpty() || trimmed == "." || trimmed == "..") return ""
-        return trimmed.filter { it.isLetterOrDigit() || it in "._-" }.take(64)
-    }
-
-    /**
-     * Whether a turn is running, so the screen can be kept awake for one.
-     *
-     * The page owns the answer — it is the only thing that knows if the kernel
-     * is working — and the shell owns the flag, because a window flag is not
-     * something a page can set. Nothing is asked at launch: a window that is
-     * merely open is one the person may be reading, and holding the screen on
-     * for that is holding it on for nothing.
-     */
-    @JavascriptInterface
-    fun setRunning(running: Boolean) {
-        onRunning?.invoke(running)
-    }
-
-    /** How the activity applies that flag. Set by the activity. */
-    var onRunning: ((Boolean) -> Unit)? = null
-
-    /**
-     * Whether the app may read every file, which is what lets the kernel open a
-     * folder on this phone as a workspace.
-     *
-     * Asked rather than assumed: the permission is granted by hand in system
-     * settings, so the page has to be able to say "not yet" rather than fail on
-     * the first `stat`. Answered `true` below API 30, where ordinary read
-     * permission is enough and the concept does not exist.
-     */
-    @JavascriptInterface
-    fun hasAllFilesAccess(): Boolean = filesAccess?.invoke() ?: true
-
-    var filesAccess: (() -> Boolean)? = null
-
-    /** Open the system page where that permission is granted. The only place
-     *  Android offers it — there is no dialog for this one. */
-    @JavascriptInterface
-    fun requestAllFilesAccess() {
-        if (!trusted()) return
-        askForFilesAccess?.invoke()
-    }
-
-    var askForFilesAccess: (() -> Unit)? = null
-
-    /**
-     * Whether this app is exempt from the system's battery optimisation.
-     *
-     * A turn runs in a child process under a foreground service. Under doze the
-     * whole app group is frozen anyway, so the turn stops making progress while
-     * the screen is off — which is the state the person left it in on purpose.
-     * Unrestricted is the answer, and it is a question Android answers.
-     */
-    @JavascriptInterface
-    fun batteryUnrestricted(): Boolean = if (!trusted()) false else (batteryFree?.invoke() ?: true)
-
-    var batteryFree: (() -> Boolean)? = null
-
-    /** Ask for that exemption. Unlike the storage one, this has a real dialog. */
-    @JavascriptInterface
-    fun requestBatteryUnrestricted() {
-        if (!trusted()) return
-        askForBattery?.invoke()
-    }
-
-    var askForBattery: (() -> Unit)? = null
-
-    /**
-     * Ask for a folder on this phone and answer with its real filesystem path.
-     *
-     * "" is a dismissal, the same answer `importIntoHome` gives — and, unlike
-     * that one, an empty string is a normal outcome here rather than a failure.
-     * The `startIn` hint is a path the kernel knows; the picker may ignore it,
-     * which is the picker's business.
-     *
-     * The round trip is the same latch as `pickFile`, for the same reason: a
-     * document-tree picker is another activity, and this call cannot suspend.
-     */
-    @JavascriptInterface
-    fun pickFolder(startIn: String): String {
-        if (!trusted()) return ""
-        val gate = CountDownLatch(1)
-        folderLatch.set(gate)
-        folderPending.set(null)
-
-        val posted = CountDownLatch(1)
-        var dispatched = false
-        main.post {
-            dispatched = runCatching { askForFolder(startIn) }.getOrDefault(false)
-            posted.countDown()
-        }
-        val ready = runCatching { posted.await(PICK_TIMEOUT_SECONDS, TimeUnit.SECONDS) }.getOrDefault(false)
-        if (!ready || !dispatched) {
-            folderLatch.set(null)
-            return ""
-        }
-        return try {
-            if (!gate.await(PICK_TIMEOUT_SECONDS, TimeUnit.SECONDS)) "" else folderPending.get().orEmpty()
-        } catch (_: InterruptedException) {
-            ""
-        } finally {
-            folderLatch.set(null)
-        }
-    }
-
-    var askForFolder: (String) -> Boolean = { false }
-
-    private val folderPending = AtomicReference<String?>(null)
-    private val folderLatch = AtomicReference<CountDownLatch?>(null)
-
-    /** Called by the activity with the folder's real path, or null on dismissal. */
-    fun deliverFolder(path: String?) {
-        folderPending.set(path ?: "")
-        folderLatch.get()?.countDown()
-    }
-
-    companion object {
-        const val BRIDGE_VERSION = "4"
-        private const val PICK_TIMEOUT_SECONDS = 5L * 60
-
-        /** Long, because this is however long someone takes to aim. A shorter
-         *  one would turn "still lining it up" into a failed scan. */
-        private const val SCAN_TIMEOUT_SECONDS = 5L * 60
-
-        /** Only as long as the sheet takes to appear: the answer is "something
-         *  took it", which is known the moment the Intent resolves. */
-        private const val SHARE_TIMEOUT_SECONDS = 15L
-    }
-}
-
-/**
- * The window's insets, in CSS pixels.
- *
- * A named type rather than four numbers because the page reads them as one
- * thing: half an inset is a layout that is wrong in one direction, and a caller
- * that passed the wrong pair would be indistinguishable from a device with no
- * cutout at all.
- */
-data class Insets(val left: Int, val top: Int, val right: Int, val bottom: Int)

android/app/src/main/java/io/reasonix/mobile/app/Qr.kt

@@ -1,66 +0,0 @@
-package io.reasonix.mobile.app
-
-import androidx.camera.core.ImageProxy
-import com.google.zxing.BarcodeFormat
-import com.google.zxing.BinaryBitmap
-import com.google.zxing.DecodeHintType
-import com.google.zxing.MultiFormatReader
-import com.google.zxing.PlanarYUVLuminanceSource
-import com.google.zxing.common.HybridBinarizer
-
-/**
- * Reading a QR code out of one camera frame.
- *
- * ZXing core and nothing else: it is pure Java, so it runs identically on a
- * phone with Google Play Services and on one whose HarmonyOS compatibility
- * layer has none. A decoder that leaned on ML Kit would work on the machine it
- * was written on and fail on the one that needs it.
- *
- * The frame arrives as YUV_420_888, whose Y plane is already the greyscale
- * bitmap ZXing wants — no conversion, no colour maths, just the bytes. That is
- * the whole reason a phone can decode 30 frames a second without warming up.
- */
-object Qr {
-
-    private val reader = MultiFormatReader().apply {
-        setHints(
-            mapOf(
-                // Only the form the computer actually renders. Leaving the
-                // reader open to every 1D barcode makes each frame slower for
-                // a case that cannot occur, and a slower frame is a code that
-                // has already left the viewfinder.
-                DecodeHintType.POSSIBLE_FORMATS to listOf(BarcodeFormat.QR_CODE),
-                DecodeHintType.TRY_HARDER to true,
-            ),
-        )
-    }
-
-    /** The code's text, or null when this frame holds none. */
-    fun decode(image: ImageProxy): String? {
-        val plane = image.planes.firstOrNull() ?: return null
-        val buffer = plane.buffer
-        val data = ByteArray(buffer.remaining())
-        buffer.get(data)
-        // `rowStride` is padded to a hardware alignment and is usually wider
-        // than the picture. Passing the width as the row length is what tells
-        // ZXing where each row actually ends; getting it wrong shears the image
-        // and every code reads as garbage.
-        val source = PlanarYUVLuminanceSource(
-            data,
-            plane.rowStride,
-            image.height,
-            0,
-            0,
-            image.width,
-            image.height,
-            false,
-        )
-        return runCatching {
-            reader.decodeWithState(BinaryBitmap(HybridBinarizer(source))).text
-        }.getOrNull().also {
-            // The reader keeps per-frame state between calls; resetting is what
-            // stops a partial match in one frame from corrupting the next.
-            reader.reset()
-        }
-    }
-}

android/app/src/main/java/io/reasonix/mobile/app/ScanActivity.kt

@@ -1,146 +0,0 @@
-package io.reasonix.mobile.app
-
-import android.Manifest
-import android.content.Intent
-import android.content.pm.PackageManager
-import android.os.Bundle
-import android.view.Gravity
-import android.view.ViewGroup
-import android.widget.FrameLayout
-import android.widget.TextView
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.appcompat.app.AppCompatActivity
-import androidx.camera.core.CameraSelector
-import androidx.camera.core.ImageAnalysis
-import androidx.camera.core.ImageProxy
-import androidx.camera.core.Preview
-import androidx.camera.lifecycle.ProcessCameraProvider
-import androidx.camera.view.PreviewView
-import androidx.core.content.ContextCompat
-import java.util.concurrent.Executors
-
-/**
- * The camera, held open just long enough to read one pairing code.
- *
- * A phone that wants to drive a computer cannot type the code that computer
- * shows: it is a base64 fragment inside a URL, and the whole point of showing it
- * as a QR code is that nobody reads one aloud. So this is the way in — the same
- * gesture the computer's own dialog asks for, from the other side.
- *
- * The decode is ZXing rather than ML Kit on purpose. ML Kit needs Google Play
- * Services, and this app installs on phones whose HarmonyOS compatibility layer
- * has none: a GMS-backed scanner would work on a developer's phone and fail on
- * the device that needs it. ZXing core is pure Java, so the scanner behaves the
- * same on both.
- *
- * It returns the first code it reads and finishes. A pairing code is
- * single-use and short-lived, so "keep scanning after a hit" is not a feature —
- * it is a way to spend a code that a later frame would have discarded.
- */
-class ScanActivity : AppCompatActivity() {
-
-    private lateinit var preview: PreviewView
-    private lateinit var hint: TextView
-    private val executor = Executors.newSingleThreadExecutor()
-
-    /** Set once a code is found, so the frames in flight behind it do not each
-     *  try to finish the activity. */
-    @Volatile
-    private var settled = false
-
-    private val requestCamera = registerForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
-        if (granted) start() else refuse()
-    }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        val root = FrameLayout(this)
-        preview = PreviewView(this).apply {
-            layoutParams = FrameLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT,
-            )
-            // The frames are analysed, not composed: filling the view and
-            // cropping is right here and would be wrong for a camera app.
-            scaleType = PreviewView.ScaleType.FILL_CENTER
-        }
-        hint = TextView(this).apply {
-            text = getString(R.string.scan_hint)
-            setTextColor(0xFFFFFFFF.toInt())
-            textSize = 14f
-            gravity = Gravity.CENTER
-            val pad = (16 * resources.displayMetrics.density).toInt()
-            setPadding(pad, pad, pad, pad)
-            // Readable over whatever the camera is pointing at, which is the
-            // one background a design system cannot choose.
-            setBackgroundColor(0x99000000.toInt())
-            layoutParams = FrameLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.WRAP_CONTENT,
-                Gravity.BOTTOM,
-            )
-        }
-        root.addView(preview)
-        root.addView(hint)
-        setContentView(root)
-
-        if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) ==
-            PackageManager.PERMISSION_GRANTED
-        ) {
-            start()
-        } else {
-            requestCamera.launch(Manifest.permission.CAMERA)
-        }
-    }
-
-    private fun refuse() {
-        // No dialog of our own: the permission prompt already said no, and a
-        // second window repeating it is one more tap to dismiss. The caller
-        // gets the same answer as a cancelled scan.
-        setResult(RESULT_CANCELED)
-        finish()
-    }
-
-    private fun start() {
-        val providerFuture = ProcessCameraProvider.getInstance(this)
-        providerFuture.addListener({
-            val provider = runCatching { providerFuture.get() }.getOrNull() ?: return@addListener refuse()
-            val previewUseCase = Preview.Builder().build().also { it.setSurfaceProvider(preview.surfaceProvider) }
-            val analysis = ImageAnalysis.Builder()
-                // Only the newest frame matters: a stale one describes where the
-                // camera was, and a code that has already left the viewfinder
-                // must not win over one that is in it now.
-                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
-                .build()
-                .also { it.setAnalyzer(executor, ::analyse) }
-            runCatching {
-                provider.unbindAll()
-                provider.bindToLifecycle(this, CameraSelector.DEFAULT_BACK_CAMERA, previewUseCase, analysis)
-            }.onFailure { refuse() }
-        }, ContextCompat.getMainExecutor(this))
-    }
-
-    private fun analyse(image: ImageProxy) {
-        try {
-            if (settled) return
-            val text = Qr.decode(image) ?: return
-            if (settled) return
-            settled = true
-            setResult(RESULT_OK, Intent().putExtra(EXTRA_TEXT, text))
-            // Finishing from the analysis thread is the whole reason `settled`
-            // exists; the activity teardown has to happen on the main one.
-            runOnUiThread { finish() }
-        } finally {
-            image.close()
-        }
-    }
-
-    override fun onDestroy() {
-        super.onDestroy()
-        executor.shutdown()
-    }
-
-    companion object {
-        const val EXTRA_TEXT = "text"
-    }
-}

android/app/src/main/res/drawable/ic_launcher_foreground.xml

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- The mark, drawn rather than shipped as a bitmap: one R in the app's own ink
-     on the palette's ground, which scales to every launcher's mask without a
-     density bucket per size. The hole in the R is the glyph's own counter, cut
-     with evenOdd rather than painted over. -->
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path
-        android:fillColor="#F4F1EA"
-        android:fillType="evenOdd"
-        android:pathData="M39,30 L39,78 L47,78 L47,60 L54.5,60 L65,78 L74.5,78 L62.5,58 C68.6,55.8 72.6,50.6 72.6,43.6 C72.6,35.4 66.8,30 57.6,30 Z M47,37 L56.4,37 C61.2,37 64.4,39.4 64.4,43.8 C64.4,48.2 61.2,50.9 56.4,50.9 L47,50.9 Z" />
-    <path
-        android:fillColor="#A6680C"
-        android:pathData="M62,66 L74,66 L74,78 L62,78 Z" />
-</vector>

android/app/src/main/res/drawable/ic_notification.xml

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- The status-bar glyph, not the launcher icon: Android renders a notification
-     icon as a mask, so anything that is not a solid silhouette on transparency
-     comes out as a grey blob. -->
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="24"
-    android:viewportHeight="24"
-    android:tint="#FFFFFF">
-    <path
-        android:fillColor="#FFFFFF"
-        android:pathData="M3,4h18v2H3zM3,9h18v2H3zM3,14h12v2H3zM3,19h12v2H3zM17.5,13.2l1.6,2.6 1.6,-2.6h2.3l-2.8,4.3V21h-2.2v-3.5L15.2,13.2z" />
-</vector>

android/app/src/main/res/layout/view_splash.xml

@@ -1,62 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  The screen between the tap and the page.
-
-  It exists for a reason that is not cosmetic: the kernel has to be unpacked and
-  started before there is a page to show, and on a cold start that is about a
-  second. A blank window for a second reads as a broken app; a line of text that
-  says what is happening does not.
-
-  The progress bar is indeterminate and driven by nothing: the WebView's own
-  progress is mirrored onto it while the page loads, and before that it simply
-  turns, which is the honest description of "we do not know how long".
--->
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    android:background="@color/page"
-    android:orientation="vertical"
-    android:gravity="center"
-    android:paddingStart="32dp"
-    android:paddingEnd="32dp">
-
-    <TextView
-        android:id="@+id/splash_wordmark"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="@string/app_name"
-        android:textColor="#8A857B"
-        android:textSize="22sp"
-        android:letterSpacing="0.08"
-        android:fontFamily="sans-serif-medium" />
-
-    <ProgressBar
-        android:id="@+id/splash_bar"
-        style="?android:attr/progressBarStyleHorizontal"
-        android:layout_width="132dp"
-        android:layout_height="wrap_content"
-        android:layout_marginTop="26dp"
-        android:indeterminate="true" />
-
-    <TextView
-        android:id="@+id/splash_text"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_marginTop="18dp"
-        android:gravity="center"
-        android:text="@string/splash_connecting"
-        android:textColor="#8A857B"
-        android:textSize="13sp"
-        android:lineSpacingMultiplier="1.5" />
-
-    <Button
-        android:id="@+id/splash_retry"
-        style="?android:attr/borderlessButtonStyle"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_marginTop="14dp"
-        android:minHeight="44dp"
-        android:text="@string/splash_retry"
-        android:textColor="#A6680C"
-        android:visibility="gone" />
-</LinearLayout>

android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- The adaptive launcher icon.
-
-     minSdk is 26, which is the release that introduced adaptive icons, so this
-     is the only launcher asset the app needs: there is no device running it
-     that would ask for a bitmap fallback. -->
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background" />
-    <!-- The safe zone is the middle 66dp of 108dp; the glyph is drawn inside it
-         so no launcher's mask can clip it. -->
-    <foreground android:drawable="@drawable/ic_launcher_foreground" />
-    <monochrome android:drawable="@drawable/ic_launcher_foreground" />
-</adaptive-icon>

android/app/src/main/res/values-en/strings.xml

@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="app_name">Reasonix</string>
-
-    <string name="channel_kernel">Kernel running</string>
-    <string name="channel_kernel_desc">Shown while the Reasonix kernel runs in the background. Can be muted on its own in system settings.</string>
-
-    <string name="notify_running_title">Reasonix is running</string>
-    <string name="notify_running_body">A task is still going. Switch back to see it.</string>
-    <string name="notify_failed_title">Reasonix could not start</string>
-
-    <string name="err_kernel_unreachable">Could not reach the kernel. Reopen the app from your home screen.</string>
-
-    <string name="download_default_name">reasonix-download</string>
-    <string name="download_saved">Saved: %1$s</string>
-    <string name="download_failed">Save failed: %1$s</string>
-    <string name="download_failed_status">Save failed: the server answered %1$d</string>
-
-    <string name="splash_connecting">Starting the kernel…</string>
-    <string name="splash_retry">Retry</string>
-
-    <string name="scan_title">Scan the code on the computer</string>
-    <string name="scan_hint">Point at the QR code in the computer\'s device panel to connect to it.</string>
-    <string name="scan_button">Scan to connect</string>
-    <string name="scan_denied">No camera permission, so scanning is unavailable. Allow it in system settings.</string>
-</resources>

android/app/src/main/res/values-night/colors.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- The dark palette's page colour. `DayNight` on the theme picks this up when
-     the system is dark, which is what keeps the frame before the WebView from
-     flashing light at someone using a dark phone at night. -->
-<resources>
-    <color name="page">#0E1014</color>
-</resources>

android/app/src/main/res/values/colors.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- The light palette's page colour, and only what the window needs before the
-     WebView paints. The interface's own colours are `tokens.css`'s and are the
-     page's business; these two exist so the first frame is the app's ground
-     rather than the platform default white. -->
-<resources>
-    <color name="page">#F4F1EA</color>
-    <color name="boot">#07080C</color>
-</resources>

android/app/src/main/res/values/ic_launcher_background.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- The launcher ground: the interface's dark page colour. It is the same in
-     both themes because a launcher icon is not themed by the app. -->
-<resources>
-    <color name="ic_launcher_background">#14161C</color>
-</resources>

android/app/src/main/res/values/strings.xml

@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Every string the shell itself shows. The interface's own text belongs to
-     the page and lives in its i18n bundle; these are only the few lines that
-     exist before it, or when it cannot load. -->
-<resources>
-    <string name="app_name">Reasonix</string>
-
-    <string name="channel_kernel">内核运行中</string>
-    <string name="channel_kernel_desc">Reasonix 内核在后台运行时显示，可在系统设置中单独关闭。</string>
-
-    <string name="notify_running_title">Reasonix 正在运行</string>
-    <string name="notify_running_body">任务继续进行，切回应用即可查看。</string>
-    <string name="notify_failed_title">Reasonix 无法启动</string>
-
-    <string name="err_kernel_unreachable">连接内核失败。请返回桌面重新打开应用。</string>
-
-    <string name="download_default_name">reasonix-download</string>
-    <string name="download_saved">已保存：%1$s</string>
-    <string name="download_failed">保存失败：%1$s</string>
-    <string name="download_failed_status">保存失败：服务器返回 %1$d</string>
-
-    <string name="splash_connecting">正在启动内核…</string>
-    <string name="splash_retry">重试</string>
-
-    <string name="wsperm_title">需要「所有文件访问」权限</string>
-    <string name="wsperm_body">要打开手机上的文件夹作为工作区，需要先允许本应用访问所有文件。点「去设置」，在列表里打开 Reasonix 的开关，然后返回这里。</string>
-    <string name="wsperm_go">去设置</string>
-    <string name="wsperm_later">以后再说</string>
-
-    <string name="scan_title">扫描电脑上的二维码</string>
-    <string name="scan_hint">对准电脑上「设备访问」里的二维码，识别后即可连接这台电脑。</string>
-    <string name="scan_button">扫码连接电脑</string>
-    <string name="scan_denied">没有相机权限，无法扫码。请在系统设置里允许。</string>
-    <string name="share_title">分享文件</string>
-</resources>

android/app/src/main/res/values/themes.xml

@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- The shell's own furniture: a window background matching the page's light
-     palette before the WebView paints, and a transparent system bar so the
-     page's own safe-area padding is what the notch meets. The page themes
-     itself; this exists only so the first frame is not a white flash. -->
-<resources xmlns:tools="http://schemas.android.com/tools">
-
-    <style name="Theme.Reasonix" parent="Theme.AppCompat.DayNight.NoActionBar">
-        <item name="android:windowBackground">@color/page</item>
-        <item name="android:statusBarColor">@android:color/transparent</item>
-        <item name="android:navigationBarColor">@android:color/transparent</item>
-        <!-- The page draws its own edge-to-edge layout and pads itself with the
-             safe-area insets from mobile.css. Laying the window out edge to edge
-             while leaving the bars transparent is what makes those insets real
-             numbers instead of zero. -->
-        <item name="android:windowLayoutInDisplayCutoutMode" tools:targetApi="p">shortEdges</item>
-        <item name="android:enforceStatusBarContrast" tools:targetApi="q">false</item>
-        <item name="android:enforceNavigationBarContrast" tools:targetApi="q">false</item>
-    </style>
-
-    <!-- The camera. A black ground because the preview has not drawn yet and a
-         light window behind a dark viewfinder is a flash in the dark; the bars
-         stay transparent so the preview reaches the edges, which is what makes
-         a code near the top of the screen scannable. -->
-    <style name="Theme.Reasonix.Scan" parent="Theme.Reasonix">
-        <item name="android:windowBackground">@android:color/black</item>
-    </style>
-</resources>

android/app/src/main/res/xml/data_extraction_rules.xml

@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  Backups are off, and this file says why rather than leaving it implicit.
-
-  A Reasonix home holds provider keys, an account token and every session
-  transcript. Android's auto-backup would copy all of it to the person's cloud
-  drive and, on a device-to-device transfer, to a new phone — which is a
-  credential leaving the device by a route nobody chose. `allowBackup="false"`
-  in the manifest turns that off; these two stanzas are the belt to its braces,
-  excluding everything explicitly so that a later change to `allowBackup` cannot
-  quietly start copying credentials.
-
-  What a person wants to move between phones, the kernel already moves: its own
-  export writes a file the person hands to the system's picker.
--->
-<data-extraction-rules>
-    <cloud-backup>
-        <exclude domain="root" />
-        <exclude domain="file" />
-        <exclude domain="database" />
-        <exclude domain="sharedpref" />
-        <exclude domain="external" />
-    </cloud-backup>
-    <device-transfer>
-        <exclude domain="root" />
-        <exclude domain="file" />
-        <exclude domain="database" />
-        <exclude domain="sharedpref" />
-        <exclude domain="external" />
-    </device-transfer>
-</data-extraction-rules>

android/app/src/main/res/xml/network_security_config.xml

@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  Cleartext HTTP is permitted, and the platform has no way to permit less.
-
-  Two kinds of page load over plain HTTP: the kernel's own page on
-  `127.0.0.1:<port>`, and the same page served by a paired computer on whatever
-  address its router handed out. The port is chosen when the kernel starts and
-  the LAN address when a code is scanned, so neither can be written here — and a
-  `domain-config` matches literals and domains, never a subnet.
-
-  So the boundary is not this file. `MainActivity` decides which cleartext origin
-  may become the window: `shouldOverrideUrlLoading` sends every http(s) origin
-  that is not the kernel's or the one just paired out to the browser, and the
-  native bridge answers only those two. A plaintext page on the LAN therefore
-  cannot become the document holding the bridge, which is what the reviewer's
-  "deliberate path for LAN pairing" asks for.
-
-  HTTPS is untouched: nothing here downgrades a request, and `trust-anchors`
-  keeps the system roots for every TLS connection that is made.
--->
-<network-security-config>
-    <base-config cleartextTrafficPermitted="true">
-        <trust-anchors>
-            <certificates src="system" />
-        </trust-anchors>
-    </base-config>
-</network-security-config>

android/build.gradle

@@ -1,15 +0,0 @@
-// The build itself lives in app/build.gradle; this file declares the plugin
-// versions once so the app module can be read on its own.
-//
-// AGP 8.11.1 is the pairing for the Gradle 8.14 toolchain this machine has:
-// AGP 8.7 and older refuse a Gradle that new, and AGP 8.13+ wants a Gradle this
-// one does not have. Both numbers are pinned rather than ranged, because a
-// build that silently moved either one would be a different build.
-plugins {
-    id "com.android.application" version "8.11.1" apply false
-    id "org.jetbrains.kotlin.android" version "2.1.20" apply false
-}
-
-tasks.register("clean", Delete) {
-    delete rootProject.layout.buildDirectory
-}

android/gradle.properties

@@ -1,15 +0,0 @@
-# AndroidX is the only copy of the support libraries this project uses; the
-# non-transitive R class keeps the app's own resources from aliasing library
-# ones, which is what makes `R.string.*` unambiguous here.
-android.useAndroidX=true
-android.nonTransitiveRClass=true
-
-# The daemon is what keeps a second `gradle assembleDebug` from re-reading the
-# whole SDK, and the heap is sized for the R8 pass over the WebView and the
-# packaged page rather than for this handful of Kotlin files.
-org.gradle.jvmargs=-Xmx3g -Dfile.encoding=UTF-8
-org.gradle.daemon=true
-org.gradle.parallel=true
-org.gradle.caching=true
-
-kotlin.code.style=official

android/gradle/wrapper/gradle-wrapper.properties

@@ -1,12 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
-# Pinning the distribution's checksum is what makes the download verifiable: a
-# mirror that served a different zip would fail here instead of being unpacked
-# and run. The value is Gradle's own, from
-# https://services.gradle.org/distributions/gradle-8.14.3-bin.zip.sha256
-distributionSha256Sum=bd71102213493060956ec229d946beee57158dbd89d0e62b91bca0fa2c5f3531
-networkTimeout=10000
-validateDistributionUrl=true
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

android/gradlew

@@ -1,251 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-# This is normally unused
-# shellcheck disable=SC2034
-APP_BASE_NAME=${0##*/}
-# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH="\\\"\\\""
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    if ! command -v java >/dev/null 2>&1
-    then
-        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
-#     and any embedded shellness will be escaped.
-#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-#     treated as '${Hostname}' itself on the command line.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
-        "$@"
-
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
-fi
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"

android/gradlew.bat

@@ -1,94 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-@rem SPDX-License-Identifier: Apache-2.0
-@rem
-
-@if "%DEBUG%"=="" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%"=="" set DIRNAME=.
-@rem This is normally unused
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if %ERRORLEVEL% equ 0 goto execute
-
-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

android/scripts/build-kernel.sh

@@ -1,64 +0,0 @@
-#!/usr/bin/env bash
-#
-# Build the Reasonix kernel for Android and place it where the APK packager
-# expects a native library.
-#
-# Why a shell script and not a Gradle task: the kernel is a Go module that lives
-# outside this Gradle build, with its own toolchain version pinned in go.mod. A
-# Gradle task that invoked `go build` would make the Android build depend on a Go
-# toolchain being configured for it, and would rebuild a 21MB binary on every
-# `assembleDebug` even when nothing in the kernel changed. This runs when you
-# mean it to, and the APK task only checks that the result is there.
-#
-# Output: app/src/main/jniLibs/arm64-v8a/libreasonix.so
-#   The name is not cosmetic. Android extracts files under `jniLibs/` to
-#   `nativeLibraryDir` and permits execution *there*; a binary shipped in
-#   `assets/` would have to be copied to app storage and chmod'd, which fails on
-#   a device whose data partition is mounted noexec. `lib*.so` is the shape the
-#   packager recognises as a native library, so the kernel wears it.
-set -euo pipefail
-
-here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-android="$here/.."
-upstream="$android/.."
-out="$android/app/src/main/jniLibs/arm64-v8a/libreasonix.so"
-
-if [ ! -d "$upstream" ]; then
-  echo "kernel source not found: $upstream" >&2
-  echo "run this from a checkout: the parent of android/ must be the kernel source." >&2
-  exit 1
-fi
-
-# GOOS=android needs nothing else: the kernel is CGO-free, which is what makes a
-# single static binary possible in the first place. `-s -w` drops the symbol and
-# DWARF tables — about a third of the file — and nothing on a phone reads them.
-export GOOS=android
-export GOARCH=arm64
-export CGO_ENABLED=0
-
-# The app version, read from the module's own build.gradle so the two cannot
-# drift. The official build stamps these through `-X` (see upstream's Makefile);
-# without them the kernel reports `version=dev revision=unknown`, which a phone
-# then shows next to the documentation it was built with and makes a bug report
-# from that build impossible to place. There is no `.git` here, so the revision
-# names the package the corpus shipped in rather than a commit hash — the honest
-# answer when there is no commit to name.
-app_gradle="$android/app/build.gradle"
-version_field() {
-  sed -n "s/^def $1 *= *\([0-9]*\).*/\1/p" "$app_gradle" | head -n1
-}
-app_version="${REASONIX_APP_VERSION:-$(version_field versionMajor).$(version_field versionMinor).$(version_field versionPatch)}"
-build_time_utc="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-ldflags="-s -w"
-ldflags="$ldflags -X main.version=v$app_version"
-ldflags="$ldflags -X main.buildTimeUTC=$build_time_utc"
-ldflags="$ldflags -X reasonix/internal/tools/productdocs.linkedVersion=v$app_version"
-ldflags="$ldflags -X reasonix/internal/tools/productdocs.linkedRevision=apk-v$app_version"
-
-echo "building the kernel (android/arm64, v$app_version) ..."
-mkdir -p "$(dirname "$out")"
-cd "$upstream"
-go build -trimpath -ldflags="$ldflags" -o "$out" ./cmd/reasonix
-
-size=$(wc -c < "$out")
-echo "kernel ready: $out ($((size / 1024 / 1024)) MiB)"

android/scripts/build.sh

@@ -1,45 +0,0 @@
-#!/usr/bin/env bash
-#
-# One command from a clean checkout to an installable APK.
-#
-# The order matters and is the whole content of this script: the kernel and the
-# page are inputs to packaging, not build steps inside it, so they are produced
-# first and the Gradle task only assembles what is already there. Running
-# `gradle assembleRelease` directly on a fresh checkout fails on purpose (see
-# `requireBuildInputs` in app/build.gradle) rather than producing an APK with no
-# kernel in it.
-#
-# Usage: ./scripts/build.sh [debug|release]     (default: release)
-set -euo pipefail
-
-here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-android="$here/.."
-variant="${1:-release}"
-
-case "$variant" in
-  debug|release) ;;
-  *) echo "usage: $0 [debug|release]" >&2; exit 2 ;;
-esac
-
-"$here/build-kernel.sh"
-"$here/sync-page.sh"
-
-cd "$android"
-
-# The wrapper is committed, jar and all, and it is the only thing that runs the
-# build. Generating one here would tie the dependency versions to whichever
-# `gradle` happened to be on PATH, which is the opposite of a pinned build.
-if [ ! -f gradlew ]; then
-  echo "gradlew is missing: this repository commits the Gradle wrapper, so the checkout is incomplete" >&2
-  echo "(a release build does not use `gradle` from PATH: that would tie dependency versions to the machine)" >&2
-  exit 1
-fi
-
-task="assemble$([ "$variant" = release ] && echo Release || echo Debug)"
-echo "packaging the APK ($variant) ..."
-./gradlew "$task" --no-daemon
-
-apk_dir="$android/app/build/outputs/apk/$variant"
-echo
-echo "done. Installable artifacts:"
-find "$apk_dir" -name '*.apk' -maxdepth 1 -print -exec ls -lh {} \;

android/scripts/run.sh

@@ -1,43 +0,0 @@
-#!/usr/bin/env bash
-#
-# Install the built APK on a connected phone and show its log.
-#
-# `adb` comes from the Android SDK rather than this project, because the SDK is
-# already how the app is built. Point ANDROID_HOME at it, or have `adb` on PATH.
-#
-# Usage: ./scripts/run.sh [debug|release]
-set -euo pipefail
-
-here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-android="$here/.."
-variant="${1:-release}"
-
-adb="${ADB:-${ANDROID_HOME:-$HOME/AndroidSDK}/platform-tools/adb}"
-if ! command -v "$adb" >/dev/null 2>&1; then
-  adb="adb"
-fi
-
-apk_dir="$android/app/build/outputs/apk/$variant"
-apk=$(find "$apk_dir" -name '*.apk' -maxdepth 1 2>/dev/null | head -n1)
-if [ -z "$apk" ]; then
-  echo "no $variant APK found; run ./scripts/build.sh $variant first" >&2
-  exit 1
-fi
-
-echo "installing $apk ..."
-"$adb" install -r "$apk"
-
-# The device count is checked before the app is started so an emulator-less
-# machine gets "no devices" rather than a launch failure that reads like a bug.
-if [ "$("$adb" devices | grep -c 'device$')" -eq 0 ]; then
-  echo "no device attached; skipping the launch." >&2
-  exit 0
-fi
-
-package="io.reasonix.mobile.app"
-[ "$variant" = debug ] && package="io.reasonix.mobile.app.debug"
-"$adb" shell monkey -p "$package" -c android.intent.category.LAUNCHER 1 >/dev/null
-
-echo
-echo "following the log (Ctrl-C to stop) ..."
-"$adb" logcat -v color "ReasonixKernel:V" "AndroidRuntime:E" "*:S"

android/scripts/sync-page.sh

@@ -1,64 +0,0 @@
-#!/usr/bin/env bash
-#
-# Build the interface and copy it where the APK will carry it.
-#
-# The page that ships is the same build the desktop Studio serves — that is the
-# whole reason the mobile layout lives in `desktop/frontend-next` rather than in
-# an Android project's own web root. Nothing is edited on the way through: the
-# only thing this script does that `pnpm build` does not is copy `dist/` into the
-# app's assets.
-#
-# Output: app/src/main/assets/page/
-set -euo pipefail
-
-here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-android="$here/.."
-frontend="$android/../desktop/frontend-next"
-dest="$android/app/src/main/assets/page"
-
-if [ ! -d "$frontend" ]; then
-  echo "frontend project not found: $frontend" >&2
-  exit 1
-fi
-
-cd "$frontend"
-
-# pnpm is the package manager the lockfile is written for; npm would resolve a
-# different tree than the one that was tested.
-if ! command -v pnpm >/dev/null 2>&1; then
-  echo "pnpm 10 is required: npm install -g pnpm@10" >&2
-  exit 1
-fi
-
-if [ ! -d node_modules ]; then
-  echo "installing frontend dependencies ..."
-  pnpm install --frozen-lockfile
-fi
-
-echo "building the frontend ..."
-pnpm build
-
-rm -rf "$dest"
-mkdir -p "$dest"
-cp -R dist/. "$dest/"
-
-if [ ! -f "$dest/index.html" ]; then
-  echo "the build produced no index.html; the frontend build probably failed." >&2
-  exit 1
-fi
-
-count=$(find "$dest" -type f | wc -l)
-size=$(du -sk "$dest" | cut -f1)
-echo "page ready: $dest ($count files, $((size / 1024)) MiB)"
-
-# MIT requires the copyright notice and the licence text to travel with a binary
-# distribution, so the APK carries it. Generated from the repository's own
-# `LICENSE` rather than committed a second time: a checked-in copy is one more
-# thing that drifts when the root file is updated.
-root_license="$android/../LICENSE"
-if [ ! -f "$root_license" ]; then
-  echo "LICENSE not found: $root_license" >&2
-  exit 1
-fi
-cp "$root_license" "$android/app/src/main/assets/LICENSE"
-echo "licence: app/src/main/assets/LICENSE (copied from the repository's LICENSE)"

android/scripts/verify-page.sh

@@ -1,95 +0,0 @@
-#!/usr/bin/env bash
-#
-# Reproduce what `Kernel.kt` does, on this machine, against the page that is
-# actually packaged into the APK.
-#
-# This is the closest thing to an end-to-end test that runs without a phone: the
-# launch flags, the token file, the port file and the `--page` directory are the
-# same ones the Kotlin shell passes, and the page is read out of
-# `app/src/main/assets/page` rather than the frontend's own `dist/`. If this
-# serves a working interface, the only untested part is Android itself.
-set -euo pipefail
-
-here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-android="$here/.."
-page="$android/app/src/main/assets/page"
-kernel="${KERNEL_BIN:-$android/../reasonix-verify.exe}"
-
-work="${VERIFY_DIR:-/tmp/reasonix-verify}"
-rm -rf "$work"
-mkdir -p "$work/home/remote"
-
-if [ ! -f "$kernel" ]; then
-  echo "no runnable kernel; build one first:" >&2
-  echo "  (cd .. && go build -o reasonix-verify.exe ./cmd/reasonix)" >&2
-  exit 1
-fi
-
-if [ ! -f "$page/index.html" ]; then
-  echo "no packaged page: $page/index.html" >&2
-  exit 1
-fi
-
-# 32 random bytes as hex — the same shape `Kernel.mintToken` writes.
-token=$(od -An -tx1 -N32 /dev/urandom | tr -d ' \n')
-# The kernel refuses a token file other users can read.
-(umask 077; printf '%s\n' "$token" > "$work/home/remote/launch.token")
-
-export REASONIX_HOME="$work/home"
-export HOME="$work/home"
-export TMPDIR="$work"
-
-echo "kernel: $kernel"
-echo "page: $page"
-echo "token: ${token:0:8}... (${#token} chars)"
-
-"$kernel" serve \
-  --addr 127.0.0.1:0 \
-  --auth token \
-  --token-file "$work/home/remote/launch.token" \
-  --port-file "$work/home/remote/serve.port" \
-  --pid-file "$work/home/remote/serve.pid" \
-  --no-open \
-  -page "$page" \
-  > "$work/kernel.log" 2>&1 &
-echo $! > "$work/kernel.pid"
-
-# Wait for the port file the kernel writes after binding, which is exactly the
-# wait `Kernel.awaitPort` performs.
-for _ in $(seq 1 150); do
-  if [ -s "$work/home/remote/serve.port" ]; then break; fi
-  if ! kill -0 "$(cat "$work/kernel.pid")" 2>/dev/null; then
-    echo "the kernel exited; log:" >&2
-    cat "$work/kernel.log" >&2
-    exit 1
-  fi
-  sleep 0.2
-done
-
-if [ ! -s "$work/home/remote/serve.port" ]; then
-  echo "the kernel reported no listening address; log:" >&2
-  cat "$work/kernel.log" >&2
-  exit 1
-fi
-
-port=$(cat "$work/home/remote/serve.port")
-echo "listening on: $port"
-
-# The two things the WebView will do: fetch the page, and exist on the origin.
-probe=$(curl -s -o /dev/null -w '%{http_code}' "http://$port/")
-echo "GET /  -> $probe"
-if [ "$probe" != "200" ]; then
-  echo "the page did not answer; log:" >&2
-  cat "$work/kernel.log" >&2
-  exit 1
-fi
-
-cat > "$work/entry.txt" <<EOF
-origin=http://$port
-entry=http://$port/#token=$token
-token=$token
-EOF
-
-echo "entry written: $work/entry.txt"
-echo "kernel log (first 10 lines):"
-head -10 "$work/kernel.log"

android/settings.gradle

@@ -1,31 +0,0 @@
-// Reasonix Mobile — the Android shell around the Reasonix kernel.
-//
-// The shell is deliberately thin: it unpacks the kernel and the built page that
-// ship inside the APK, starts `reasonix serve` on a loopback port, and points a
-// WebView at it. Everything the person sees and does is the same page the
-// desktop Studio and `reasonix web` serve, because it is literally the same
-// build of `desktop/frontend-next` — which is what keeps one interface honest
-// across the three surfaces, and why the page is packaged rather than fetched.
-
-pluginManagement {
-    repositories {
-        // The official repositories only. A mirror listed here would be an
-        // unverified trust anchor for anything that ends up in a signed build:
-        // the artifact it serves is whichever copy landed there. A machine that
-        // needs a mirror belongs on a user-level init script, where the choice
-        // stays with the person building rather than travelling with the source.
-        google()
-        mavenCentral()
-        gradlePluginPortal()
-    }
-}
-
-dependencyResolutionManagement {
-    repositories {
-        google()
-        mavenCentral()
-    }
-}
-
-rootProject.name = "ReasonixMobile"
-include(":app")

benchmarks/README.md

@@ -1,6 +1,6 @@
 # Reasonix Benchmarks
 
-Six harnesses live under `benchmarks/`; `cmd/e2ebench` also exposes a
+Five harnesses live under `benchmarks/`; `cmd/e2ebench` also exposes a
 SWE-bench Verified mode:
 
 - `e2e/` — the committed end-to-end task suite, driven by
@@ -19,10 +19,6 @@ SWE-bench Verified mode:
 - `fanout-width/` — a shape-instructed fleet whose members share nothing, for
   pricing what running them at the same time is worth. See
   [Pricing the run graph](#pricing-the-run-graph) below.
-- `realrepo/` — long tasks over a pinned snapshot of this repository, for
-  measuring changes that cut model round trips (13–31 requests per task on
-  `deepseek-flash`). See
-  [its README](realrepo/README.md).
 
 ## Directory layout
 
@@ -420,7 +416,7 @@ own outcome).
 
 | Flag | Default | Purpose |
 | --- | --- | --- |
-| `-mode` | `suite` | `suite` \| `diff` \| `swebench` \| `compare` \| `traj` (`diff` generates tests for the PR diff; `swebench` runs the official per-instance evaluation; `compare` renders KPI/Pareto readouts from 2+ `-json` reports; `traj` re-digests recorded trajectory files without spending tokens; `audit` checks a batch's published figures against its retained rows). |
+| `-mode` | `suite` | `suite` \| `diff` \| `swebench` \| `compare` \| `traj` (`diff` generates tests for the PR diff; `swebench` runs the official per-instance evaluation; `compare` renders KPI/Pareto readouts from 2+ `-json` reports; `traj` re-digests recorded trajectory files without spending tokens). |
 | `-suite` | `benchmarks/e2e` | Suite root (must contain `tasks/<id>/`). |
 | `-task` | *(all)* | Suite mode: run only these comma-separated task IDs (e.g. `-task fix-add-bug`); unknown IDs fail with the available list. |
 | `-attempts` | `1` | Suite and diff modes: retry a task until an attempt passes, up to N; enables the `Pass@≤N` KPI, and TTCS charges a retried solve with its failed attempts' wall. |
@@ -433,7 +429,6 @@ own outcome).
 | `-ablate` | *(none)* | Ablation arm: comma-separated subsystems to switch off — `evidence`, `planner`, `subagent`, `retrieval`, `compaction`, `upstream` and `recall-search`; `none` \| `all`. |
 | `-out` | *(stdout)* | Write the markdown report here. |
 | `-json` | *(none)* | Write the JSON report here (optional). |
-| `-batch` | *(none)* | Suite mode: write `results.jsonl` (one row per attempt) and `batch.json` (manifest v1) here, so the report's figures can be audited later. Audit mode: read the batch from here. See [Auditing a batch](#auditing-a-batch). |
 | `-trajectories` | *(none)* | Suite mode: write one `<task-id>.trajectory.jsonl` per task into this directory (the agent's full event stream with timestamps — see `reasonix run --trajectory`). The report gains a time-attribution line (tools vs. model) and each JSON result a `trajectory` digest. |
 | `-force-planner` | `false` | Suite mode: prefix each prompt with a plan-first directive so the two-model turn engages regardless of the planner gate. Use for the "with planner" arm of an A/B; results carry `plan_forced` so arms are only comparable with equal forcing. |
 | `-anchor` | `blind` | Suite mode: which hypothesis the agent holds before it looks at anything — `blind` (none, the control) \| `correct` \| `wrong`. The seeded arms prefix each prompt with the task's authored seed and **skip** tasks that have none, so an unseeded control run never lands in a seeded denominator. Results carry `anchor`. See [Anchor resistance](#anchor-resistance). |
@@ -456,65 +451,10 @@ Diff-mode flags:
 | `-timeout` | `1200` | Agent timeout in seconds (diff mode). |
 | `-attempts` | `1` | Diff mode: retry up to N times until a run passes (stochastic agent). |
 
-## Auditing a batch
-
-`-batch DIR` writes two files from a suite run: `results.jsonl` (one row per
-attempt — the raw record every figure is computed from) and `batch.json`
-(manifest v1). `-mode audit -batch DIR` re-derives the report's headline figures
-from `results.jsonl`, prints the manifest's claim beside the recomputed value,
-and exits non-zero naming any figure that moved. It also refuses a batch whose
-manifest is missing, records no commit, or whose rows are truncated.
-
-This is an **aggregation audit, not a replay**: it proves the published figures
-follow from the retained rows. It does not re-execute the model, tools or
-environment, and cannot show the experiment would reproduce. A real replay would
-need the commit, a corpus fingerprint, the model and provider configuration, the
-seed, the flags, the raw results and the runtime version; it is not implemented.
-
-`schema_version` is top level. The rest is three groups:
-
-| Group | Fields | Answers |
-| --- | --- | --- |
-| `over` | `command.mode` and `command.axes` (every flag that changes what a figure means; paths omitted); `tasks.count` and `tasks.digest` (sha256 over sorted, NUL-separated task ids — the corpus identity, never the task text); `filters`; `denominator` (`unit`, `definition`, `value`) | what the figures are over |
-| `producer` | `commit` (or an explicit `unknown`, never a guess), `commit_source`, `dirty`, `model`, `provider`, `seed`, `started_at`, `finished_at`, `harness_version`, `go_version` | which run produced them |
-| `trust` | `results_sha256`, `claimed` (the headline figures), `ledger`, `retention` | why they can still be checked |
-
-The ledger accounts for every planned run, and the audit checks that the counts
-form a funnel (`scored ≤ completed ≤ attempted`, `failed ≤ scored`,
-`scored = pass1 + failed`, `rows = attempted + skipped`). A row count is never a
-denominator: `denominator.value` is a count of scored tasks, and `rows` is
-published only to show what was retained.
-
-| Count | Meaning |
-| --- | --- |
-| `planned` | graded runs the batch set out to attempt: filtered tasks × trials |
-| `attempted` | retained rows for runs that started (skipped rows are not attempts) |
-| `completed` | attempts that ended and left a row; this harness writes a row only after an attempt ends, so it equals `attempted` and the equality is checked, not assumed |
-| `scored` | completed first attempts of solvable, non-skipped tasks — the pass@1 denominator |
-| `failed` | scored attempts the grader did not pass |
-| `unmeasured` | attempts whose cost and tokens are unknown because no metrics landed; kept out of spend totals, never counted as zero |
-| `excluded` | rows kept out of the accuracy denominator: skipped, `no_solution`, and retry entries |
-
-Spend and cache fields are omitted from `claimed` when nothing was measured, so
-an absent figure reads as unknown rather than as a measured zero. `seed` is
-omitted for the same reason: the harness does not set a sampling seed.
-`results_sha256` covers the values and the presence of every row; line endings,
-indentation and key order are normalised away because none of them is evidence,
-while number spelling is kept (a rewritten `1` is not `1.0`).
-A successful audit records the verifier version (`audit.verifier_version`) and
-the digest it checked in `batch.json`, so a re-verification can tell which code
-checked the batch.
-
-`results.jsonl` is retained unredacted beside the manifest — task prompts and
-agent notes included — and is not public. The manifest itself carries a task-id
-digest, no prompt text, no absolute paths, no endpoints or keys and no model
-output. A claim whose rows are gone cannot be audited: there is nothing to
-recompute from, and this tool will not certify it.
-
 ## Dataset retention
 
-Keep every `-json` report, `-trajectories` directory and `-batch` directory from
-real runs: they are the accumulating corpus — per-task contracts-to-be, full event
+Keep every `-json` report and `-trajectories` directory from real runs: they
+are the accumulating corpus — per-task contracts-to-be, full event
 trajectories, checkpoint oracle verdicts, stop curves and phase traces — that
 any future offline learning (routing, stop policies, budgets) would train
 and evaluate on. The control plane stays deterministic and interpretable

benchmarks/compaction/cache-prefix/README.md

@@ -1,35 +0,0 @@
-# Compaction prefix probe
-
-## Method
-
-1. Measured on 2026-10-17 against the official `https://api.deepseek.com` OpenAI adapter, using the model returned by `/models`: `deepseek-flash`. Thinking was disabled. Inputs were synthetic; no workspace history or credentials are recorded here.
-2. Each of three text and three rich-history trials sent a main request to warm the prefix, then called the actual agent summary path, then an independent summary control. Rich history included a synthetic closed `read_file` call, result and reasoning. Warmup outputs were discarded, never executed.
-3. A summary had a 1,024-token output cap; warmups had 64. Success means a heading, preservation of the fixture's `ParseDuration` and zero-value constraint, no emitted tool calls, and `finish_reason=stop`. This checks the fixture's contract, not arbitrary-summary factual completeness.
-4. First-attempt reuse success counts successful reused summaries / six reused summaries. Fallback rate counts independent requests initiated by the reuse coordinator / six reuse trials; the six explicit independent controls are excluded. Both were 6/6 success and 0/6 fallbacks. Independent controls also succeeded 6/6.
-5. The raw result file records provider-reported usage and full stream latency, measured from adapter `Stream` until channel close. Token rows below sum only the three indicated summary requests; they exclude warmup, model listing and any earlier exploratory requests. Cache residency was uncontrolled; prior probes had warmed these synthetic prefixes.
-
-## Results
-
-| History | Shape | N | Prompt | Hit | Miss | Output | Median ms | Estimated USD |
-| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-| Text | Reused | 3 | 3,714 | 3,072 | 642 | 636 | 1,713 | 0.000487116 |
-| Text | Independent | 3 | 1,218 | 768 | 450 | 644 | 1,610 | 0.000456204 |
-| Rich | Reused | 3 | 3,780 | 3,072 | 708 | 742 | 1,774 | 0.000560616 |
-| Rich | Independent | 3 | 1,341 | 768 | 573 | 921 | 1,815 | 0.000640854 |
-
-1. Estimates use the [official pricing](https://api-docs.deepseek.com/quick_start/pricing/) checked on the measurement date: off-peak Flash USD per million tokens, hit 0.003, miss 0.15, output 0.6. October 17 was a Saturday. Formula: `(hit*0.003 + miss*0.15 + output*0.6)/1_000_000`. These are token estimates, not account deductions.
-2. Reuse hit fractions were 82.7% (text) and 81.3% (rich), versus 63.1% and 57.3% for controls. This small fixture does **not** establish cost savings: retaining the system/catalog increased both total input and input cost. Text total cost increased 6.8%; rich total decreased 12.5% because output was shorter, not because input was cheaper.
-3. The six warmups consumed 7,032 prompt and 231 output tokens, estimated USD 0.000346680. All 18 recorded generation calls together cost an estimated USD 0.002491470. No failed-digest retry occurred in these live trials; the deterministic fallback tests establish its behavior and accounting.
-4. A rejected nonempty reused answer earns one independent-shape fallback. A separate truncation retry may enlarge the output cap, for at most three logical model calls total. Every actual attempt emits and records its own spend; returned usage is their sum. Empty output, stream errors and cancellation do not earn shape retries.
-5. These sequential, six-pair trials establish interoperability for one model, mode and short fixture. They do not estimate production failure probability, thinking-mode behavior, other models, cold-cache cost, or large-history savings.
-
-## Reproduction
-
-1. Provide a test key through an existing secret environment configuration. Do not put credentials in source, command arguments or captured logs. Select a model currently returned by `/models`.
-2. Run the opt-in probe; it skips without `DEEPSEEK_API_KEY`. The dedicated build tag avoids enabling unrelated live tests.
-
-```sh
-REASONIX_LIVE_MODEL=deepseek-flash go test -tags live_compaction ./internal/runtime/agent -run '^TestLiveCompactionPrefix$' -v -count=1
-```
-
-3. This probe exercises actual summary construction and the HTTP adapter. The hermetic `TestEffectCompactionSharesThePreviouslySentPrefix` separately exercises manual, automatic pressure and rich history through `boot.Build`, comparing actual JSON request-prefix and schema bytes. Its sparse-history case also proves an interleaved retained user turn survives the fold.

benchmarks/compaction/cache-prefix/deepseek-flash-2026-10-17.json

@@ -1,512 +0,0 @@
-[
-  {
-    "model": "deepseek-flash",
-    "rich": false,
-    "trial": 1,
-    "results": [
-      {
-        "kind": "warm",
-        "milliseconds": 828,
-        "digest": false,
-        "grounded": false,
-        "tool_calls": 1,
-        "usage": {
-          "PromptTokens": 1127,
-          "CompletionTokens": 38,
-          "TotalTokens": 1165,
-          "CacheHitTokens": 896,
-          "CacheMissTokens": 231,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "tool_calls",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      },
-      {
-        "kind": "reuse",
-        "milliseconds": 2006,
-        "digest": true,
-        "grounded": true,
-        "tool_calls": 0,
-        "usage": {
-          "PromptTokens": 1238,
-          "CompletionTokens": 234,
-          "TotalTokens": 1472,
-          "CacheHitTokens": 1024,
-          "CacheMissTokens": 214,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "stop",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      },
-      {
-        "kind": "independent",
-        "milliseconds": 1817,
-        "digest": true,
-        "grounded": true,
-        "tool_calls": 0,
-        "usage": {
-          "PromptTokens": 406,
-          "CompletionTokens": 234,
-          "TotalTokens": 640,
-          "CacheHitTokens": 256,
-          "CacheMissTokens": 150,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "stop",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      }
-    ]
-  },
-  {
-    "model": "deepseek-flash",
-    "rich": false,
-    "trial": 2,
-    "results": [
-      {
-        "kind": "warm",
-        "milliseconds": 820,
-        "digest": false,
-        "grounded": false,
-        "tool_calls": 1,
-        "usage": {
-          "PromptTokens": 1127,
-          "CompletionTokens": 38,
-          "TotalTokens": 1165,
-          "CacheHitTokens": 896,
-          "CacheMissTokens": 231,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "tool_calls",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      },
-      {
-        "kind": "reuse",
-        "milliseconds": 1633,
-        "digest": true,
-        "grounded": true,
-        "tool_calls": 0,
-        "usage": {
-          "PromptTokens": 1238,
-          "CompletionTokens": 187,
-          "TotalTokens": 1425,
-          "CacheHitTokens": 1024,
-          "CacheMissTokens": 214,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "stop",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      },
-      {
-        "kind": "independent",
-        "milliseconds": 1555,
-        "digest": true,
-        "grounded": true,
-        "tool_calls": 0,
-        "usage": {
-          "PromptTokens": 406,
-          "CompletionTokens": 202,
-          "TotalTokens": 608,
-          "CacheHitTokens": 256,
-          "CacheMissTokens": 150,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "stop",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      }
-    ]
-  },
-  {
-    "model": "deepseek-flash",
-    "rich": false,
-    "trial": 3,
-    "results": [
-      {
-        "kind": "warm",
-        "milliseconds": 905,
-        "digest": false,
-        "grounded": false,
-        "tool_calls": 1,
-        "usage": {
-          "PromptTokens": 1127,
-          "CompletionTokens": 38,
-          "TotalTokens": 1165,
-          "CacheHitTokens": 896,
-          "CacheMissTokens": 231,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "tool_calls",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      },
-      {
-        "kind": "reuse",
-        "milliseconds": 1713,
-        "digest": true,
-        "grounded": true,
-        "tool_calls": 0,
-        "usage": {
-          "PromptTokens": 1238,
-          "CompletionTokens": 215,
-          "TotalTokens": 1453,
-          "CacheHitTokens": 1024,
-          "CacheMissTokens": 214,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "stop",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      },
-      {
-        "kind": "independent",
-        "milliseconds": 1610,
-        "digest": true,
-        "grounded": true,
-        "tool_calls": 0,
-        "usage": {
-          "PromptTokens": 406,
-          "CompletionTokens": 208,
-          "TotalTokens": 614,
-          "CacheHitTokens": 256,
-          "CacheMissTokens": 150,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "stop",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      }
-    ]
-  },
-  {
-    "model": "deepseek-flash",
-    "rich": true,
-    "trial": 1,
-    "results": [
-      {
-        "kind": "warm",
-        "milliseconds": 561,
-        "digest": false,
-        "grounded": false,
-        "tool_calls": 1,
-        "usage": {
-          "PromptTokens": 1217,
-          "CompletionTokens": 39,
-          "TotalTokens": 1256,
-          "CacheHitTokens": 1024,
-          "CacheMissTokens": 193,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "tool_calls",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      },
-      {
-        "kind": "reuse",
-        "milliseconds": 1774,
-        "digest": true,
-        "grounded": true,
-        "tool_calls": 0,
-        "usage": {
-          "PromptTokens": 1260,
-          "CompletionTokens": 256,
-          "TotalTokens": 1516,
-          "CacheHitTokens": 1024,
-          "CacheMissTokens": 236,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "stop",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      },
-      {
-        "kind": "independent",
-        "milliseconds": 2271,
-        "digest": true,
-        "grounded": true,
-        "tool_calls": 0,
-        "usage": {
-          "PromptTokens": 447,
-          "CompletionTokens": 381,
-          "TotalTokens": 828,
-          "CacheHitTokens": 256,
-          "CacheMissTokens": 191,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "stop",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      }
-    ]
-  },
-  {
-    "model": "deepseek-flash",
-    "rich": true,
-    "trial": 2,
-    "results": [
-      {
-        "kind": "warm",
-        "milliseconds": 610,
-        "digest": false,
-        "grounded": false,
-        "tool_calls": 1,
-        "usage": {
-          "PromptTokens": 1217,
-          "CompletionTokens": 39,
-          "TotalTokens": 1256,
-          "CacheHitTokens": 1024,
-          "CacheMissTokens": 193,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "tool_calls",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      },
-      {
-        "kind": "reuse",
-        "milliseconds": 2263,
-        "digest": true,
-        "grounded": true,
-        "tool_calls": 0,
-        "usage": {
-          "PromptTokens": 1260,
-          "CompletionTokens": 276,
-          "TotalTokens": 1536,
-          "CacheHitTokens": 1024,
-          "CacheMissTokens": 236,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "stop",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      },
-      {
-        "kind": "independent",
-        "milliseconds": 1783,
-        "digest": true,
-        "grounded": true,
-        "tool_calls": 0,
-        "usage": {
-          "PromptTokens": 447,
-          "CompletionTokens": 242,
-          "TotalTokens": 689,
-          "CacheHitTokens": 256,
-          "CacheMissTokens": 191,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "stop",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      }
-    ]
-  },
-  {
-    "model": "deepseek-flash",
-    "rich": true,
-    "trial": 3,
-    "results": [
-      {
-        "kind": "warm",
-        "milliseconds": 834,
-        "digest": false,
-        "grounded": false,
-        "tool_calls": 1,
-        "usage": {
-          "PromptTokens": 1217,
-          "CompletionTokens": 39,
-          "TotalTokens": 1256,
-          "CacheHitTokens": 1024,
-          "CacheMissTokens": 193,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "tool_calls",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      },
-      {
-        "kind": "reuse",
-        "milliseconds": 1575,
-        "digest": true,
-        "grounded": true,
-        "tool_calls": 0,
-        "usage": {
-          "PromptTokens": 1260,
-          "CompletionTokens": 210,
-          "TotalTokens": 1470,
-          "CacheHitTokens": 1024,
-          "CacheMissTokens": 236,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "stop",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      },
-      {
-        "kind": "independent",
-        "milliseconds": 1815,
-        "digest": true,
-        "grounded": true,
-        "tool_calls": 0,
-        "usage": {
-          "PromptTokens": 447,
-          "CompletionTokens": 298,
-          "TotalTokens": 745,
-          "CacheHitTokens": 256,
-          "CacheMissTokens": 191,
-          "CacheWriteTokens": 0,
-          "CacheWriteBilledTokens": 0,
-          "ReasoningTokens": 0,
-          "FinishReason": "stop",
-          "Estimated": false,
-          "RequestCount": 1,
-          "ServerToolRequests": 0,
-          "ContextPromptTokens": 0,
-          "ContextCompletionTokens": 0,
-          "ContextReasoningTokens": 0,
-          "ContextCacheHitTokens": 0,
-          "ContextCacheMissTokens": 0
-        }
-      }
-    ]
-  }
-]

benchmarks/compaction/main.go

@@ -103,6 +103,10 @@ func newHarness(t *testingDir, p provider.Provider, window int, rec *callRecorde
 		ContextWindow: window,
 		ArchiveDir:    filepath.Join(t.dir, "archive"),
 		SessionPath:   path,
+		RecentKeep:    4,
+		// boot's default when cfg.Agent.Keep is unset; without it the bench
+		// would measure a configuration no real session runs.
+		KeepPolicy: agent.KeepErrors,
 	}, rec.sink())
 	return &harness{sess: sess, agentA: a, path: path, calls: rec}
 }

benchmarks/context-maintenance-e2e/main.go

@@ -108,6 +108,7 @@ func newAgent(p provider.Provider, sess *sessionstore.Session, path string, sink
 	return agent.New(p, tool.NewRegistry(), sess, agent.Options{
 		ContextWindow: windowTokens,
 		CompactRatio:  compactRatio,
+		RecentKeep:    2,
 		SessionPath:   path,
 		WorkspaceID:   "cm-e2e",
 		ModelRef:      "deepseek/" + model,

benchmarks/context-retrieval/README.md

@@ -0,0 +1,180 @@
+# Context retrieval bench
+
+Two questions about long-horizon memory, and the harness that makes their
+answers trustworthy.
+
+    -mode=preflight     build all 18 tasks under every arm and check the contract
+    -mode=snippet       does a rank-1 hit hand over the whole answer?
+    -mode=adversarial   send a model after the answer through every host surface
+    -mode=run-search    Experiment R: is searchable canonical a real capability?
+    -mode=run-boundary  Experiment I, paired: the 6 efficiency tasks across their boundary
+    -mode=run-index     Experiment I, full: the 6 efficiency tasks x 4 budgets
+    -mode=calibrate     find each index task's PlantAfterGen for its cue tier
+
+`-dry` drives any run mode with a scripted provider, for nothing. Real runs need
+`DEEPSEEK_API_KEY`.
+
+## Status
+
+**Searchable canonical recall: proven.** Six of six recovered with search on,
+three of six with it off, and the successes without it came from enumerating
+addresses by hand at roughly nine times the page-in cost (139 vs 1292
+tokens/task). Measured after three separate leaks were closed, so the numbers
+are from a clean environment.
+
+**Fold index marginal utility: direction reproduced, size still conditional.** On the v2
+substrate the direction holds in six of six tasks and in the pooled paired batch: with the
+cue visible the index addresses the target, so the same task is searched less and pages in
+less (0.67 searches and 70 recall tokens per task, against 1.50 and 120 with the cue
+absent).
+
+A size is visible but is not yet quotable. On the four tasks whose absent-cue arm stayed
+out of a loop, the index cost 64,952 prompt tokens against 115,551 without, 44% less
+(`i106-budgetseal` -35,147, `i70-ingestfloor` -8,222, `i37-dispatchlag` -7,599, and
+`i112-lagquota` +369, the prefix rent a task that never searches pays). That is a
+**post-hoc subset**: `i118-fencelag` and `i47-tenantlease` are excluded because their
+absent-cue arm looped in this batch (five and three retrieval rounds, three escapes each;
+together 80% of the absent-cue total), and the qualification above does not screen for
+stopping behaviour — holding on both boundary arms across three passes shows a stable cue
+boundary, not a stopping arm. Quoting 44% as the index's effect would mean choosing the
+sample after seeing the result; a batch screened on stopping stability is what would make
+a size quotable, and one arm also reverses either way (`i70-ingestfloor` default, +11,135
+prompt tokens over three escapes).
+
+Batch facts, because the counts differ: 36 runs were executed (12 paired, 24 index), and
+the token totals here cover the 24-run index batch — the paired batch ran before the
+per-run usage line existed.
+
+**Things that turned out not to be problems**, each after being measured rather
+than argued about:
+
+| Suspected | Measured |
+| --- | --- |
+| Model writes poor queries (2.17 searches/task) | 22/23 found the target on query 1; the extra searches are one round's parallel fan-out |
+| Model reaches for the workspace before memory (7/11) | Linear event order misread; by model round it is MemoryFirst 4/6 |
+| Snippets too short for multi-value answers | 240 runes covers 12/12 tasks at 100%; records are 30-179 runes |
+| A general stopping failure | 37/44 runs issued no search after the answer was in hand; all 7 that did belong to 2 tasks |
+
+## Measurement distinctions this bench had to learn
+
+Each of these reversed a conclusion once. They are enforced in the schema now,
+not left to whoever reads the numbers next.
+
+- **TargetHit is not EvidenceSufficient.** A rank-1 hit can return a window too
+  short to answer with. `FirstHitCoverage` records how much of the scored answer
+  the first hit actually handed over.
+- **Linear event order is not model-round order.** Two calls in one round are a
+  parallel fan-out, not a preference. Routing compares rounds.
+- **An isolated workdir is not an isolated host.** The sandbox mounts the host
+  read-only by design. Three leaks were found and closed: the corpus source, the
+  fixture transcript, and its event log sidecar.
+- **A count is not its evidence.** Query text, snippet contents and trajectories
+  are all persisted now, because three analyses in a row needed a paid re-run to
+  ask a question of data already collected.
+
+## How a run stays honest
+
+The corpus holds templates, never answers: every scored literal is a `{{var}}`
+instantiated per run, so grepping this directory reveals the question and not
+the answer. `TestNoAnswerLiteralExistsInTheRepository` asserts it with
+`git grep`. Preflight rebuilds every arm and checks the answer is unreadable in
+the real `provider.Request`, the probe query ranks the target within five, and
+an index task's cue sits at exactly the scales its tier names. The fixture is
+removed from disk once the agent holds it in memory, and the directory is
+scanned for answer literals before the first provider request and again after
+the turn. Any answer reaching the model through a tool that is not `recall`
+marks the run contaminated and takes it out of every statistic.
+
+## Index corpus v2
+
+The efficiency substrate is six tasks that hold on both arms: `i37-dispatchlag`
+and `i118-fencelag` (quarter), `i106-budgetseal` and `i70-ingestfloor` (half),
+`i47-tenantlease` and `i112-lagquota` (default).
+
+They came out of five batches of candidates, each screened the same way: one
+`-mode=run-index` pass over the batch, then two more only for the candidates that
+were clean on both boundary arms, and only the candidates that held on both arms
+in all three passes stayed. A candidate that does not hold is dropped, not
+promoted. The numbers are candidates, per tier:
+
+| batch | quarter | half | default |
+| --- | --- | --- | --- |
+| first pool, `i31`-`i54` | 1 of 8 | 0 of 8 | 2 of 8 |
+| second pool, `i61`-`i84` | 1 of 4 screened | 4 of 8 | 0 of 8 |
+| third pool, `i85`-`i108` | 2 of 8 | 8 of 16 | none authored |
+| replacement pool, `i109`-`i116` | - | - | 4 of 8 |
+| replacement pool, `i92`, `i117`-`i124` | 3 of 9 | - | - |
+
+That table counts candidates that held on both arms in all three passes, which is
+not the size of the substrate. 89 candidates were authored, 77 were screened (the
+second pool's quarter tier stopped at 4 of 8 and its default tier was never run),
+and 25 held: 7 quarter, 12 half, 6 default. The substrate keeps two per tier, so
+the other 19 survivors are spares rather than corpus members. Candidates from the
+earlier round are not counted here.
+
+| task | tier | cue present | cue absent |
+| --- | --- | ---: | ---: |
+| `i37-dispatchlag` | quarter | 3/3 | 3/3 |
+| `i118-fencelag` | quarter | 3/3 | 3/3 |
+| `i106-budgetseal` | half | 3/3 | 3/3 |
+| `i70-ingestfloor` | half | 3/3 | 3/3 |
+| `i47-tenantlease` | default | 3/3 | 3/3 |
+| `i112-lagquota` | default | 3/3 | 3/3 |
+
+Across their 36 judged cells: `SnippetStop` 23, `SnippetThenRead` 10 and
+`DefensiveRead` 3 - every cell clean, nothing post-sufficient and nothing
+`NeverSufficient`.
+
+Four of the first six were flagged in review for sharing answer values, probe
+queries and prompt wording within a tier. Separating them and re-screening those
+four changed two of them: `i37` and `i47` held, `i62` and `i51` did not, so they
+were replaced - `i90-recoverylag` was tried first and did not hold either, and
+`i118-fencelag` and `i112-lagquota` are what did. The separation was not
+cosmetic: the shared wording had been carrying two of the six.
+
+Nothing in the task shape separates the survivors from the rest: within the half
+tier, plain-number answers survived 0 of 8 in the first pool and 4 of 8 in the
+second, and codename answers survived 8 of 16 in the third. An earlier claim here
+that the answer kind decides whether a candidate holds does not survive this
+table and is withdrawn. The dirty class was `PostSufficientRetrieval` in most
+failures - the model re-checking a value it already had - but which tasks hit it
+was not predictable from their shape at this sample.
+
+`i01`-`i06` are the frozen study's six tasks, kept as `roleStopping`. Measured
+once each with `-mode=run-index -task <id>`, per task and per arm:
+
+| task | tier | cue present | cue absent |
+| --- | --- | --- | --- |
+| `i01-transport-fallback` | quarter | SnippetStop | DefensiveRead |
+| `i02-scheduler-handoff` | quarter | PostSufficientRetrieval | PostSufficientRetrieval |
+| `i03-coalescing` | half | PostSufficientRetrieval | PostSufficientRunaway |
+| `i04-recovery-fence` | half | DefensiveRead | PostSufficientRunaway |
+| `i05-cache-probe` | default | SnippetThenRead | PostSufficientRetrieval |
+| `i06-dispatch-handoff` | default | SnippetStop | PostSufficientRetrieval |
+
+Five of the six show post-sufficient behaviour in at least one arm (`i02`-`i06`),
+and `i01` is clean on both. The cue-present arm is clean for four of them
+(`i01`, `i04`, `i05`, `i06`), which is why they stay in the corpus as the
+stopping side rather than being retitled. All six are excluded from `run-index`
+and `run-boundary` batches and stay measurable one at a time with `-task <id>`. A
+task added to the corpus declares a role, so it cannot arrive without one.
+
+A task qualifies only if it is clean on both of its boundary arms - the
+cue-present run and the cue-absent run - in every run of a screening batch. Clean
+means a `stopping_class` other than `PostSufficientRetrieval` or
+`PostSufficientRunaway`: `SnippetStop`, `SnippetThenRead` and `DefensiveRead`
+all qualify, and a defensive read is deliberately not counted as waste. The
+class comes from the three counts in that report — `searches_after_sufficient`,
+`reads_after_sufficient` and `escapes_after_sufficient` — together with how
+sufficiency was reached and how many rounds followed it. The remaining
+requirements still apply — successful tool call, answer in the output rather
+than the cue, rank 1, `FirstHitCoverage` complete, one or two simple values,
+nothing in the workspace.
+
+`-mode=calibrate` is not a screening tool: it builds and reads back the
+fixtures, and reads nothing else, so its cue-visibility profile is the same for
+every task.
+
+Then repeats rather than levels: cue-present against cue-absent on each task's
+own boundary, three runs per cell. What is unknown is the variance, and four
+budgets sampled once each cannot show it.

benchmarks/context-retrieval/capture.go

@@ -0,0 +1,171 @@
+// capture.go — what the agent actually hands a provider.
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"reasonix/internal/state/sessionstore"
+	"strings"
+
+	"reasonix/internal/assembly/boot"
+	"reasonix/internal/contract/ablation"
+	"reasonix/internal/contract/event"
+	"reasonix/internal/contract/provider"
+	"reasonix/internal/contract/tool"
+	"reasonix/internal/runtime/agent"
+	_ "reasonix/internal/tools/builtin"
+)
+
+// A projection is what the agent believes; a provider.Request is what the model
+// is told. Rendering, sanitization and tool-schema construction sit between
+// them, so the arm's contract is checked on the request.
+
+type captureProvider struct {
+	requests []provider.Request
+}
+
+func (p *captureProvider) Name() string { return "contextbench-capture" }
+
+// Stream records the request and answers with a clean terminal response. An
+// empty answer would buy an empty-final retry and a second request, which is
+// not the one round this is here to inspect.
+func (p *captureProvider) Stream(_ context.Context, req provider.Request) (<-chan provider.Chunk, error) {
+	p.requests = append(p.requests, cloneRequest(req))
+	ch := make(chan provider.Chunk, 2)
+	ch <- provider.Chunk{Type: provider.ChunkText, Text: "contextbench preflight complete"}
+	ch <- provider.Chunk{Type: provider.ChunkDone}
+	close(ch)
+	return ch, nil
+}
+
+func cloneRequest(req provider.Request) provider.Request {
+	out := req
+	out.Messages = append([]provider.Message(nil), req.Messages...)
+	out.Tools = append([]provider.ToolSchema(nil), req.Tools...)
+	return out
+}
+
+// captureRequest rebuilds the session the way a resume does — transcript from
+// disk, projection from its sidecar, the shipped tool surface at this arm —
+// and returns the request the first round hands the provider.
+func captureRequest(f builtFixture, arm ablation.Set, prompt string) (provider.Request, error) {
+	sess, err := sessionstore.LoadSession(f.Path)
+	if err != nil {
+		return provider.Request{}, fmt.Errorf("load session: %w", err)
+	}
+	reg := tool.NewRegistry()
+	for _, t := range tool.Builtins() {
+		reg.Add(t)
+	}
+	boot.ApplyUnifiedProviderToolSurface(reg, false, arm)
+
+	cap := &captureProvider{}
+	a := agent.New(cap, reg, sess, agent.Options{
+		ContextWindow: fixtureWindow, CompactRatio: 0.5, RecentKeep: 2,
+		SessionPath: f.Path, KeepPolicy: agent.KeepErrors, Ablation: arm,
+	}, event.Discard)
+	a.LoadProjectionSidecar(f.Path)
+
+	if err := a.Run(context.Background(), prompt); err != nil {
+		return provider.Request{}, fmt.Errorf("run: %w", err)
+	}
+	// The turn's own request is the one carrying tools. A fold on the way in
+	// asks the same provider for a digest, and that request has none — taking
+	// the first request blindly would inspect the summarizer's prompt.
+	for _, req := range cap.requests {
+		if len(req.Tools) > 0 {
+			return req, nil
+		}
+	}
+	return provider.Request{}, fmt.Errorf("no request carried tools (%d captured)", len(cap.requests))
+}
+
+// surfaceField is one place a model could read a string, named so a leak
+// report says where rather than only that.
+type surfaceField struct {
+	Path string
+	Text string
+}
+
+// providerSurface enumerates every provider-visible string in a request.
+// Enumerated rather than marshalled whole: a Message also carries local-only
+// fields, and scanning those would fail on bytes no model ever sees.
+func providerSurface(req provider.Request) []surfaceField {
+	var out []surfaceField
+	add := func(path, text string) {
+		if strings.TrimSpace(text) != "" {
+			out = append(out, surfaceField{Path: path, Text: text})
+		}
+	}
+	for i, m := range req.Messages {
+		add(fmt.Sprintf("messages[%d].content", i), m.Content)
+		add(fmt.Sprintf("messages[%d].reasoning_content", i), m.ReasoningContent)
+		add(fmt.Sprintf("messages[%d].name", i), m.Name)
+		for j, tc := range m.ToolCalls {
+			add(fmt.Sprintf("messages[%d].tool_calls[%d].name", i, j), tc.Name)
+			add(fmt.Sprintf("messages[%d].tool_calls[%d].arguments", i, j), tc.Arguments)
+		}
+		for j, item := range m.ResponsesItems {
+			add(fmt.Sprintf("messages[%d].responses_items[%d]", i, j), string(item))
+		}
+	}
+	for i, t := range req.Tools {
+		add(fmt.Sprintf("tools[%d].name", i), t.Name)
+		add(fmt.Sprintf("tools[%d].description", i), t.Description)
+		if len(t.Parameters) > 0 {
+			b, err := json.Marshal(t.Parameters)
+			if err == nil {
+				add(fmt.Sprintf("tools[%d].parameters", i), string(b))
+			}
+		}
+	}
+	return out
+}
+
+// findInSurface reports every place a marker is readable.
+func findInSurface(req provider.Request, marker string) []string {
+	var hits []string
+	for _, f := range providerSurface(req) {
+		if strings.Contains(f.Text, marker) {
+			hits = append(hits, f.Path)
+		}
+	}
+	return hits
+}
+
+// recallToolSchema returns the recall tool as the provider sees it.
+func recallToolSchema(req provider.Request) (provider.ToolSchema, bool) {
+	for _, t := range req.Tools {
+		if t.Name == "recall" {
+			return t, true
+		}
+	}
+	return provider.ToolSchema{}, false
+}
+
+// localOnlyLeaks reports host-side fields that should never survive the
+// provider boundary. A hit here is a boundary regression, marker or no marker.
+func localOnlyLeaks(req provider.Request) []string {
+	var out []string
+	for i, m := range req.Messages {
+		switch {
+		case m.RawContent != "":
+			out = append(out, fmt.Sprintf("messages[%d].raw_content", i))
+		case m.LocalOnly:
+			out = append(out, fmt.Sprintf("messages[%d].local_only", i))
+		case m.DecisionReceipt != nil || len(m.DecisionReceipts) > 0:
+			out = append(out, fmt.Sprintf("messages[%d].decision_receipt", i))
+		case m.ToolExecution != nil:
+			out = append(out, fmt.Sprintf("messages[%d].tool_execution", i))
+		case len(m.MemoryCitations) > 0:
+			out = append(out, fmt.Sprintf("messages[%d].memory_citations", i))
+		}
+	}
+	return out
+}
+
+// searchWording is what a search-off arm must never be told. The arm exists to
+// reproduce the runtime before search; an arm offered a capability it does not
+// have is a different experiment.
+var searchWording = []string{"recall with a query", "search the whole folded region", "query still finds"}

benchmarks/context-retrieval/contextbench.go

@@ -0,0 +1,657 @@
+// contextbench.go — what the model did with the affordance, read off structure.
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+
+	"reasonix/internal/base/tokencount"
+	"reasonix/internal/contract/provider"
+)
+
+// Every judgement here reads a tool call's name and its JSON arguments, or a
+// canonical position, and never the model's prose. "I will search the history"
+// is not a search; a recall call with a query is.
+
+// failure stages, in funnel order. Exactly one is reported per run.
+const (
+	stageReadMissed   = "NoSearch"           // never asked, and never read the target either
+	stageSearchMiss   = "SearchMiss"         // searched, target never came back
+	stageHitNotRead   = "HitNotRead"         // target was returned and never opened
+	stageAnswerWrong  = "ReadButAnswerWrong" // opened it and still answered wrong
+	stageRecovered    = "Recovered"
+	stageContaminated = "Contaminated"
+
+	// Routing is judged by model round, not by the linear order of tool events:
+	// two calls in one round are one parallel fan-out, and calling that
+	// "workspace first" would report a choice the model never made.
+	routeMemoryFirst    = "MemoryFirst"
+	routeWorkspaceFirst = "WorkspaceFirst"
+	routeParallel       = "Parallel"
+	routeNeither        = "Neither"
+	stageCueRead        = "DirectRead"  // read the target from an index address, no search needed
+	stageNoRetrieval    = "NoRetrieval" // answered without touching recall at all
+	toolRecall          = "recall"
+)
+
+// searchAttempt is one query the model wrote, and what it got back. Kept per
+// attempt rather than aggregated: the question is why a retrieval that the host
+// probe ranks first takes the model more than one try.
+type searchAttempt struct {
+	Ordinal     int    `json:"ordinal"`
+	Round       int    `json:"round"`
+	Query       string `json:"query"`
+	TargetRank  int    `json:"target_rank"` // 0 = the target did not come back
+	ResultCount int    `json:"result_count"`
+	// Reformulation classifies this query against the one before it, and
+	// MissingProbeTerms are the host probe's terms this query left out. Both
+	// are derived from token sets: no judge, and nothing read out of prose.
+	Reformulation     string   `json:"reformulation,omitempty"`
+	MissingProbeTerms []string `json:"missing_probe_terms,omitempty"`
+}
+
+// contextMetrics is one run's behaviour.
+type contextMetrics struct {
+	Task string `json:"task"`
+	Arm  string `json:"arm"`
+
+	SearchCalls int `json:"search_calls"`
+	// SearchHits counts searches that returned anything; TargetSearchHits
+	// counts searches that returned the target. The gap is query quality.
+	SearchHits       int `json:"search_hits"`
+	TargetSearchHits int `json:"target_search_hits"`
+	FirstTargetRank  int `json:"first_target_rank"` // 0 = never returned
+	// FirstHitCoverage: how much of the answer the first hit handed over.
+	// rank=1 with coverage 1/3 is a window too short to answer with, not a
+	// model that would not stop.
+	FirstHitCoverage int `json:"first_hit_coverage"`
+	AnswerValues     int `json:"answer_values"`
+
+	ReadCalls    int  `json:"read_calls"`
+	TargetRead   bool `json:"target_read"`
+	ReadAfterHit bool `json:"read_after_hit"`
+	// RecallReadWithoutSearch: the index addressed the target, so no search was
+	// needed. Not "direct read" — read_file is a read too, and in an audit the
+	// two mean opposite things.
+	RecallReadWithoutSearch bool `json:"recall_read_without_search"`
+	SearchThenRecallRead    bool `json:"search_then_recall_read"`
+
+	FirstSearchRound int `json:"first_search_round"`
+	FirstReadRound   int `json:"first_read_round"`
+	RetrievalRounds  int `json:"retrieval_rounds"`
+
+	// RecallReturnedTokens is what recall paged back in. The index saves
+	// resident prefix; this is what is paid dynamically instead.
+	RecallReturnedTokens int `json:"recall_returned_tokens"`
+
+	// Provider usage as reported on the stream, or empty for a dry run. The count
+	// is completions that reported usage, so it is not a count of attempts.
+	UsageReportedRequests int  `json:"usage_reported_requests,omitempty"`
+	PromptTokens          int  `json:"prompt_tokens,omitempty"`
+	CompletionTokens      int  `json:"completion_tokens,omitempty"`
+	CacheHitTokens        int  `json:"cache_hit_tokens,omitempty"`
+	CacheMissTokens       int  `json:"cache_miss_tokens,omitempty"`
+	UsageEstimated        bool `json:"usage_estimated,omitempty"`
+
+	Searches []searchAttempt `json:"searches,omitempty"`
+	// PostHitSearches are queries issued after the target had already been
+	// returned: not a query problem, a result-to-read problem.
+	PostHitSearches int `json:"post_hit_searches"`
+
+	AnswerRecovered bool `json:"answer_recovered"`
+	// AnswerAmbiguous marks an answer that offered more than one candidate for
+	// a value. Markers matching proves the right fact appears; it does not
+	// prove it was submitted as the answer. Recorded, never acted on.
+	AnswerAmbiguous bool     `json:"answer_ambiguous,omitempty"`
+	AmbiguousVar    string   `json:"ambiguous_var,omitempty"`
+	MissingMarkers  []string `json:"missing_markers,omitempty"`
+	// FinalAnswer is kept bounded so a surprising run can be read back. A
+	// metric nobody can audit is a claim, not a measurement.
+	FinalAnswer   string `json:"final_answer,omitempty"`
+	FailureStage  string `json:"failure_stage"`
+	TimeoutReason string `json:"timeout_reason,omitempty"`
+
+	// UnexpectedWorkTools are investigation tools used instead of recall.
+	// Reaching for the workspace is behaviour, not noise: how a model routes
+	// its uncertainty when memory is missing is part of what is measured.
+	UnexpectedWorkTools     []string `json:"unexpected_work_tools,omitempty"`
+	EscapeCalls             int      `json:"escape_calls"`
+	EscapeBeforeFirstRecall int      `json:"escape_before_first_recall"`
+	EscapeAfterFirstRecall  int      `json:"escape_after_first_recall"`
+	// Contaminated: the answer was reachable through something other than
+	// recall. Asserting this beats trusting the isolation, and a run that trips
+	// it leaves the statistics rather than inflating one.
+	Contaminated bool   `json:"contaminated,omitempty"`
+	LeakedVia    string `json:"leaked_via,omitempty"`
+	LeakedMarker string `json:"leaked_marker,omitempty"`
+	LeakedArgs   string `json:"leaked_args,omitempty"`
+	LeakedOutput string `json:"leaked_output,omitempty"`
+	// EscapeFoundAnswer separates "looked at the workspace" from "found the
+	// answer there": different facts about the same call.
+	EscapeFoundAnswer bool `json:"escape_found_answer,omitempty"`
+
+	CueVisible bool `json:"cue_visible"`
+
+	// trajectory is kept out of the metric line and written beside it, so a
+	// future question can be asked of this batch instead of a new one.
+	trajectory []provider.Message
+
+	// CueDirectRead: the cue was addressed, the first memory action was a
+	// positions read, and it covered the target. Crediting any positions call
+	// would hand the index a search's work.
+	CueDirectRead bool `json:"cue_direct_read"`
+
+	// Sufficiency, not hit. A search that returns the target at rank 1 has not
+	// necessarily returned the answer: the snippet is bounded. The stopping
+	// boundary is the round where everything needed was readable.
+	FirstSufficientRound        int    `json:"first_sufficient_round"`
+	SufficientVia               string `json:"sufficient_via"` // snippet | read | never
+	RoundsAfterSufficient       int    `json:"rounds_after_sufficient"`
+	SearchesAfterSufficient     int    `json:"searches_after_sufficient"`
+	ReadsAfterSufficient        int    `json:"reads_after_sufficient"`
+	EscapesAfterSufficient      int    `json:"escapes_after_sufficient"`
+	RecallTokensAfterSufficient int    `json:"recall_tokens_after_sufficient"`
+	StoppingClass               string `json:"stopping_class"`
+
+	// What happened after the answer was already in hand. A timeout that spent
+	// seven rounds past its target is a stopping problem, and extending the
+	// budget would only buy the loop more time.
+	TargetFirstSeenRound    int  `json:"target_first_seen_round"`
+	RoundsAfterTarget       int  `json:"rounds_after_target"`
+	SearchesAfterTarget     int  `json:"searches_after_target"`
+	RecallTokensAfterTarget int  `json:"recall_tokens_after_target"`
+	TargetHeldAtEnd         bool `json:"target_held_at_end"`
+
+	// Routing is where the model looked first when its memory was missing.
+	Routing          string `json:"routing"`
+	FirstRecallRound int    `json:"first_recall_round"`
+	FirstEscapeRound int    `json:"first_escape_round"`
+}
+
+// hitPosition matches the address recall prints for a search hit. Reading our
+// own rendered format, not guessing at the model's words.
+var hitPosition = regexp.MustCompile(`(?m)^#(\d+) `)
+
+// scoreRun reads the messages one turn appended and reports what happened.
+// runScorer walks one turn's messages, holding the state a judgement needs:
+// which calls are open, whether the target has come back, and which search
+// each result belongs to.
+type runScorer struct {
+	m            contextMetrics
+	inst         fixtureInstance
+	target       int
+	calls        map[string]provider.ToolCall
+	pending      map[string]int
+	round        int
+	sawTargetHit bool
+	// seen accumulates everything recall has shown the model, so sufficiency is
+	// judged on what it could read rather than on which call produced it.
+	seen       strings.Builder
+	sufficient bool
+}
+
+// scoreRun reads the messages one turn appended and reports what happened.
+func scoreRun(msgs []provider.Message, inst fixtureInstance, target int, arm string, cueVisible bool) contextMetrics {
+	s := &runScorer{
+		m:    contextMetrics{Task: inst.Task.ID, Arm: arm, CueVisible: cueVisible},
+		inst: inst, target: target,
+		calls: map[string]provider.ToolCall{}, pending: map[string]int{},
+	}
+	for _, msg := range msgs {
+		if len(msg.ToolCalls) > 0 {
+			s.round++
+		}
+		for _, tc := range msg.ToolCalls {
+			s.calls[tc.ID] = tc
+			s.observeCall(tc)
+		}
+		if msg.Role == provider.RoleTool {
+			s.observeResult(msg)
+		}
+	}
+	return s.finish(cueVisible)
+}
+
+// observeCall records one tool call: a recall search, a recall read, or a
+// reach for the workspace.
+func (s *runScorer) observeCall(tc provider.ToolCall) {
+	m := &s.m
+	if tc.Name != toolRecall {
+		if !containsString(m.UnexpectedWorkTools, tc.Name) {
+			m.UnexpectedWorkTools = append(m.UnexpectedWorkTools, tc.Name)
+		}
+		m.EscapeCalls++
+		if s.sufficient {
+			m.EscapesAfterSufficient++
+		}
+		if m.FirstEscapeRound == 0 {
+			m.FirstEscapeRound = s.round
+		}
+		if m.SearchCalls+m.ReadCalls == 0 {
+			m.EscapeBeforeFirstRecall++
+		} else {
+			m.EscapeAfterFirstRecall++
+		}
+		return
+	}
+	if m.FirstRecallRound == 0 {
+		m.FirstRecallRound = s.round
+	}
+	query, positions := recallArgs(tc.Arguments)
+	switch {
+	case query != "":
+		m.SearchCalls++
+		if m.FirstSearchRound == 0 {
+			m.FirstSearchRound = s.round
+		}
+		if s.sawTargetHit {
+			m.PostHitSearches++
+			m.SearchesAfterTarget++
+		}
+		if s.sufficient {
+			m.SearchesAfterSufficient++
+		}
+		m.Searches = append(m.Searches, searchAttempt{Ordinal: m.SearchCalls, Round: s.round, Query: query})
+		s.pending[tc.ID] = len(m.Searches) - 1
+	case len(positions) > 0:
+		m.ReadCalls++
+		if s.sufficient {
+			m.ReadsAfterSufficient++
+		}
+		if m.FirstReadRound == 0 {
+			m.FirstReadRound = s.round
+		}
+		// A read covers the target when it names its position: recall returns
+		// the tool results under the caller's own address.
+		if containsInt(positions, s.target) {
+			m.TargetRead = true
+			switch {
+			case s.sawTargetHit:
+				m.ReadAfterHit, m.SearchThenRecallRead = true, true
+			case m.SearchCalls == 0:
+				m.RecallReadWithoutSearch = true
+			}
+		}
+	}
+}
+
+// observeResult reads what a call returned: contamination, page-in cost, and
+// whether this search brought the target back.
+func (s *runScorer) observeResult(msg provider.Message) {
+	m := &s.m
+	call, ok := s.calls[msg.ToolCallID]
+	if !ok {
+		return
+	}
+	if call.Name != toolRecall {
+		// Codenames only: a three-digit epoch appears in any long file by
+		// chance, and one did. A model holding the codename holds the numbers
+		// beside it anyway.
+		for _, marker := range s.inst.AnswerMarkers {
+			if len(marker) >= 6 && strings.Contains(msg.Content, marker) {
+				m.Contaminated, m.LeakedVia, m.LeakedMarker = true, call.Name, marker
+				m.EscapeFoundAnswer = true
+				m.LeakedArgs, m.LeakedOutput = truncate(call.Arguments, 200), truncate(msg.Content, 300)
+			}
+		}
+		return
+	}
+	cost := tokencount.Text(msg.Content)
+	m.RecallReturnedTokens += cost
+	if s.sawTargetHit {
+		m.RecallTokensAfterTarget += cost
+	}
+	if s.sufficient {
+		m.RecallTokensAfterSufficient += cost
+	}
+	// Everything recall showed the model, judged as a whole: the answer may
+	// arrive across a snippet and a read, and either way it is readable.
+	s.seen.WriteString(msg.Content)
+	s.seen.WriteString("\n")
+	if !s.sufficient && allMarkersIn(s.seen.String(), s.inst.AnswerMarkers) {
+		s.sufficient = true
+		m.FirstSufficientRound = s.round
+		query, _ := recallArgs(call.Arguments)
+		m.SufficientVia = "read"
+		if query != "" {
+			m.SufficientVia = "snippet"
+		}
+	}
+	if query, _ := recallArgs(call.Arguments); query == "" {
+		return
+	}
+	positions := searchHitPositions(msg.Content)
+	if len(positions) > 0 {
+		m.SearchHits++
+	}
+	rank := indexOfInt(positions, s.target)
+	if i, ok := s.pending[msg.ToolCallID]; ok {
+		m.Searches[i].TargetRank, m.Searches[i].ResultCount = rank, len(positions)
+	}
+	if rank == 0 {
+		return
+	}
+	m.TargetSearchHits++
+	if !s.sawTargetHit {
+		m.TargetFirstSeenRound = s.round
+		m.FirstHitCoverage = answerCoverage(msg.Content, s.inst.AnswerMarkers)
+	}
+	s.sawTargetHit = true
+	if m.FirstTargetRank == 0 {
+		m.FirstTargetRank = rank
+	}
+}
+
+// finish derives what only the whole walk can say.
+func (s *runScorer) finish(cueVisible bool) contextMetrics {
+	m := s.m
+	m.RetrievalRounds = m.SearchCalls + m.ReadCalls
+	m.TargetHeldAtEnd = s.sawTargetHit || m.TargetRead
+	if m.TargetFirstSeenRound > 0 {
+		m.RoundsAfterTarget = s.round - m.TargetFirstSeenRound
+	}
+	m.Routing = routing(m.FirstRecallRound, m.FirstEscapeRound)
+	m.CueDirectRead = cueVisible && m.RecallReadWithoutSearch
+	if m.SufficientVia == "" {
+		m.SufficientVia = "never"
+	}
+	if m.FirstSufficientRound > 0 {
+		m.RoundsAfterSufficient = s.round - m.FirstSufficientRound
+	}
+	m.AnswerValues = len(s.inst.AnswerMarkers)
+	m.StoppingClass = stoppingClass(m)
+	classifySearches(&m, s.inst)
+	return m
+}
+
+// scoreAnswer grades the final text on the task's markers. Nonces, matched
+// exactly: no judge model, and nothing a general answer could satisfy.
+func (m *contextMetrics) scoreAnswer(final string, inst fixtureInstance) {
+	lower := strings.ToLower(final)
+	for _, marker := range inst.AnswerMarkers {
+		if !strings.Contains(lower, strings.ToLower(marker)) {
+			m.MissingMarkers = append(m.MissingMarkers, marker)
+		}
+	}
+	m.AnswerRecovered = len(m.MissingMarkers) == 0
+	m.AnswerAmbiguous, m.AmbiguousVar = ambiguousAnswer(final, inst)
+	m.FailureStage = m.stage()
+	if len(final) > 1200 {
+		final = final[:1200] + "…"
+	}
+	m.FinalAnswer = final
+}
+
+// stage places the run in the funnel. One label, chosen at the first step that
+// did not happen, so a table of stages reads as where the retrieval broke.
+func (m contextMetrics) stage() string {
+	switch {
+	case m.Contaminated:
+		return stageContaminated
+	case m.AnswerRecovered && m.RecallReadWithoutSearch:
+		return stageCueRead
+	case m.AnswerRecovered:
+		return stageRecovered
+	case m.TargetRead:
+		return stageAnswerWrong
+	case m.TargetSearchHits > 0:
+		return stageHitNotRead
+	case m.SearchCalls > 0:
+		return stageSearchMiss
+	case m.ReadCalls > 0:
+		return stageReadMissed
+	default:
+		return stageNoRetrieval
+	}
+}
+
+// recallArgs pulls the two fields that say which operation a recall call is.
+func recallArgs(args string) (query string, positions []int) {
+	var parsed struct {
+		Query     string `json:"query"`
+		Positions []int  `json:"positions"`
+	}
+	if err := json.Unmarshal([]byte(args), &parsed); err != nil {
+		return "", nil
+	}
+	return strings.TrimSpace(parsed.Query), parsed.Positions
+}
+
+// searchHitPositions reads the addresses out of a search result, in rank order.
+func searchHitPositions(text string) []int {
+	var out []int
+	for _, match := range hitPosition.FindAllStringSubmatch(text, -1) {
+		if n, err := strconv.Atoi(match[1]); err == nil {
+			out = append(out, n)
+		}
+	}
+	return out
+}
+
+func containsInt(list []int, want int) bool { return slices.Contains(list, want) }
+
+// indexOfInt returns a 1-based rank, or 0 when absent.
+func indexOfInt(list []int, want int) int {
+	for i, v := range list {
+		if v == want {
+			return i + 1
+		}
+	}
+	return 0
+}
+
+func containsString(list []string, want string) bool { return slices.Contains(list, want) }
+
+// funnel summarizes one arm's runs the way the experiment is read.
+type funnel struct {
+	Arm                                       string
+	Runs                                      int
+	Scored, Contaminated, Errored             int
+	Searched, TargetHit, TargetRead, Answered int
+	CueReads                                  int
+	SearchCalls, ReadCalls, RecallTokens      int
+	Escapes, EscapeCalls                      int
+	Stages, Routes                            map[string]int
+}
+
+func summarize(arm string, runs []contextMetrics) funnel {
+	f := funnel{Arm: arm, Runs: len(runs), Stages: map[string]int{}, Routes: map[string]int{}}
+	for _, r := range runs {
+		if r.Contaminated {
+			f.Contaminated++
+			f.Stages[r.FailureStage]++
+			continue
+		}
+		if r.FailureStage == "RunError" {
+			f.Errored++
+			f.Stages[r.FailureStage]++
+			continue
+		}
+		f.Scored++
+		if r.SearchCalls > 0 {
+			f.Searched++
+		}
+		if r.TargetSearchHits > 0 {
+			f.TargetHit++
+		}
+		if r.TargetRead {
+			f.TargetRead++
+		}
+		if r.AnswerRecovered {
+			f.Answered++
+		}
+		if r.RecallReadWithoutSearch {
+			f.CueReads++
+		}
+		if len(r.UnexpectedWorkTools) > 0 {
+			f.Escapes++
+		}
+		f.EscapeCalls += r.EscapeCalls
+		f.SearchCalls += r.SearchCalls
+		f.ReadCalls += r.ReadCalls
+		f.RecallTokens += r.RecallReturnedTokens
+		f.Stages[r.FailureStage]++
+		if r.FailureStage != "RunError" {
+			f.Routes[r.Routing]++
+		}
+	}
+	return f
+}
+
+func (f funnel) line() string {
+	per := func(n int) float64 {
+		if f.Scored == 0 {
+			return 0
+		}
+		return float64(n) / float64(f.Scored)
+	}
+	line := fmt.Sprintf("%-14s runs=%-3d answered=%d/%d  searched=%d  target-hit=%d  cue-read=%d  search/task=%.2f  recall-tok/task=%.0f  escape/task=%.2f",
+		f.Arm, f.Scored, f.Answered, f.Scored, f.Searched, f.TargetHit, f.CueReads,
+		per(f.SearchCalls), per(f.RecallTokens), per(f.EscapeCalls))
+	if f.Contaminated > 0 {
+		line += fmt.Sprintf("  CONTAMINATED=%d", f.Contaminated)
+	}
+	if f.Errored > 0 {
+		line += fmt.Sprintf("  ERRORED=%d", f.Errored)
+	}
+	return line
+}
+
+func writeJSONLine(w io.Writer, v any) error {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+	_, err = fmt.Fprintln(w, string(b))
+	return err
+}
+
+func truncate(s string, n int) string {
+	if len(s) <= n {
+		return s
+	}
+	return s[:n] + "…"
+}
+
+// routing says where the model looked first, comparing rounds rather than
+// event order. Same round is a parallel fan-out, not a preference.
+func routing(recallRound, escapeRound int) string {
+	switch {
+	case recallRound == 0 && escapeRound == 0:
+		return routeNeither
+	case recallRound == 0:
+		return routeWorkspaceFirst
+	case escapeRound == 0:
+		return routeMemoryFirst
+	case recallRound < escapeRound:
+		return routeMemoryFirst
+	case escapeRound < recallRound:
+		return routeWorkspaceFirst
+	default:
+		return routeParallel
+	}
+}
+
+// ambiguousAnswer reports an answer naming more than one candidate of a
+// codename's shape. Only codenames are checked: they carry a stem this run
+// declared, so two distinct "fence-…" values in one answer is one answer too
+// many. Numbers have no such shape and are left alone.
+func ambiguousAnswer(final string, inst fixtureInstance) (bool, string) {
+	for _, spec := range inst.Task.Vars {
+		if spec.Kind != varCodename {
+			continue
+		}
+		seen := map[string]bool{}
+		for _, match := range regexp.MustCompile(regexp.QuoteMeta(spec.Word)+`-[a-z0-9]{3,}`).FindAllString(final, -1) {
+			seen[match] = true
+		}
+		if len(seen) > 1 {
+			return true, spec.Name
+		}
+	}
+	return false, ""
+}
+
+func allMarkersIn(text string, markers []string) bool {
+	if len(markers) == 0 {
+		return false
+	}
+	lower := strings.ToLower(text)
+	for _, marker := range markers {
+		if !strings.Contains(lower, strings.ToLower(marker)) {
+			return false
+		}
+	}
+	return true
+}
+
+// Stopping classes. The boundary is sufficiency, not the target coming back:
+// a rank-1 hit whose snippet was too short to answer leaves a read entirely
+// justified, and counting that as waste would blame the model for the bound.
+const (
+	stopSnippet       = "SnippetStop"             // enough arrived, and the turn ended
+	stopSnippetRead   = "SnippetThenRead"         // the snippet was short; the read finished it
+	stopDefensiveRead = "DefensiveRead"           // enough had arrived, one read confirmed it
+	stopPostRetrieval = "PostSufficientRetrieval" // enough had arrived, and retrieval continued
+	stopRunaway       = "PostSufficientRunaway"   // it continued for rounds, or ran out of budget
+	stopNeverEnough   = "NeverSufficient"
+)
+
+// runawayRounds is where continuing stops looking like confirmation.
+const runawayRounds = 3
+
+func stoppingClass(m contextMetrics) string {
+	if m.FirstSufficientRound == 0 {
+		return stopNeverEnough
+	}
+	after := m.SearchesAfterSufficient + m.ReadsAfterSufficient + m.EscapesAfterSufficient
+	switch {
+	case after == 0 && m.SufficientVia == "snippet":
+		return stopSnippet
+	case after == 0:
+		return stopSnippetRead
+	case m.RoundsAfterSufficient >= runawayRounds || m.FailureStage == "RunError":
+		return stopRunaway
+	case after == 1 && m.ReadsAfterSufficient == 1:
+		return stopDefensiveRead
+	default:
+		return stopPostRetrieval
+	}
+}
+
+// reportStopping is the funnel that matters once retrieval succeeds: what the
+// turn did after it already had everything it needed.
+func reportStopping(all []contextMetrics) string {
+	classes := map[string]int{}
+	var extraRounds, extraTokens []float64
+	sufficient, answeredNext := 0, 0
+	for _, m := range all {
+		if m.Contaminated {
+			continue
+		}
+		classes[m.StoppingClass]++
+		if m.FirstSufficientRound == 0 {
+			continue
+		}
+		sufficient++
+		extraRounds = append(extraRounds, float64(m.RoundsAfterSufficient))
+		extraTokens = append(extraTokens, float64(m.RecallTokensAfterSufficient))
+		if m.RoundsAfterSufficient <= 1 {
+			answeredNext++
+		}
+	}
+	var b strings.Builder
+	b.WriteString("\n## After the evidence was already enough\n")
+	fmt.Fprintf(&b, "  sufficient in %d runs; ended within one round in %d\n", sufficient, answeredNext)
+	fmt.Fprintf(&b, "  extra rounds  mean %.1f  median %.1f  p90 %.0f  max %.0f\n",
+		mean(extraRounds), median(extraRounds), percentile(extraRounds, 0.9), maxOf(extraRounds))
+	fmt.Fprintf(&b, "  extra recall tokens  mean %.0f  median %.0f  p90 %.0f  max %.0f\n",
+		mean(extraTokens), median(extraTokens), percentile(extraTokens, 0.9), maxOf(extraTokens))
+	b.WriteString("  " + countsLine(classes) + "\n")
+	return b.String()
+}

benchmarks/context-retrieval/contextbench_test.go

@@ -0,0 +1,337 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"reasonix/internal/contract/provider"
+)
+
+// The scorer decides what the pilot concludes, so it is held to the same rule
+// the corpus is: judgements read structure. A model that says it will search
+// has not searched; a recall call carrying a query has.
+
+const scorerTarget = 42
+
+func recallCall(id, args string) provider.Message {
+	return provider.Message{Role: provider.RoleAssistant, ToolCalls: []provider.ToolCall{
+		{ID: id, Name: "recall", Arguments: args},
+	}}
+}
+
+func toolResult(id, text string) provider.Message {
+	return provider.Message{Role: provider.RoleTool, ToolCallID: id, Name: "recall", Content: text}
+}
+
+func hitBlock(positions ...int) string {
+	var b strings.Builder
+	b.WriteString("Folded context matching \"x\":\n")
+	for _, p := range positions {
+		fmt.Fprintf(&b, "\n#%d assistant_text\nsome snippet here\n", p)
+	}
+	return b.String()
+}
+
+func scorerTask() fixtureInstance {
+	return fixtureInstance{Task: contextTask{ID: "t"}, AnswerMarkers: []string{"cobalt-lark-17"}}
+}
+
+func score(t *testing.T, msgs []provider.Message, final string) contextMetrics {
+	t.Helper()
+	m := scoreRun(msgs, scorerTask(), scorerTarget, "arm", false)
+	m.scoreAnswer(final, scorerTask())
+	return m
+}
+
+// The whole funnel, walked end to end.
+func TestScorerReadsTheFullRetrievalChain(t *testing.T) {
+	m := score(t, []provider.Message{
+		recallCall("c1", `{"query":"retry boundary"}`),
+		toolResult("c1", hitBlock(7, scorerTarget)),
+		recallCall("c2", fmt.Sprintf(`{"positions":[%d]}`, scorerTarget)),
+		toolResult("c2", "#42\n[assistant]\nthe ownership token is cobalt-lark-17"),
+		{Role: provider.RoleAssistant, Content: "The token was cobalt-lark-17."},
+	}, "The token was cobalt-lark-17.")
+
+	if m.SearchCalls != 1 || m.ReadCalls != 1 {
+		t.Errorf("calls = %d search / %d read, want 1/1", m.SearchCalls, m.ReadCalls)
+	}
+	if m.TargetSearchHits != 1 || m.FirstTargetRank != 2 {
+		t.Errorf("target hit %d at rank %d, want 1 at rank 2", m.TargetSearchHits, m.FirstTargetRank)
+	}
+	if !m.TargetRead || !m.ReadAfterHit || m.RecallReadWithoutSearch {
+		t.Errorf("read flags = read %v afterHit %v direct %v", m.TargetRead, m.ReadAfterHit, m.RecallReadWithoutSearch)
+	}
+	if !m.AnswerRecovered || m.FailureStage != stageRecovered {
+		t.Errorf("stage = %q recovered=%v, want Recovered", m.FailureStage, m.AnswerRecovered)
+	}
+	if m.RecallReturnedTokens == 0 {
+		t.Error("recall returned tokens were not counted")
+	}
+}
+
+// An index arm's claim: the address was already on screen, so no search was
+// needed. That is a different outcome from finding it, and gets its own stage.
+func TestScorerSeparatesCueReadFromSearch(t *testing.T) {
+	m := score(t, []provider.Message{
+		recallCall("c1", fmt.Sprintf(`{"positions":[%d]}`, scorerTarget)),
+		toolResult("c1", "#42\nthe ownership token is cobalt-lark-17"),
+		{Role: provider.RoleAssistant, Content: "cobalt-lark-17"},
+	}, "cobalt-lark-17")
+
+	if m.SearchCalls != 0 || !m.RecallReadWithoutSearch {
+		t.Errorf("search=%d direct=%v, want 0 and true", m.SearchCalls, m.RecallReadWithoutSearch)
+	}
+	if m.FailureStage != stageCueRead {
+		t.Errorf("stage = %q, want %q", m.FailureStage, stageCueRead)
+	}
+}
+
+// Every way the chain can break gets its own label, so a failed run says where
+// rather than only that.
+func TestScorerNamesWhereTheChainBroke(t *testing.T) {
+	for _, tc := range []struct {
+		name  string
+		msgs  []provider.Message
+		final string
+		want  string
+	}{
+		{
+			name:  "never touched recall",
+			msgs:  []provider.Message{{Role: provider.RoleAssistant, Content: "I do not recall that."}},
+			final: "I do not recall that.",
+			want:  stageNoRetrieval,
+		},
+		{
+			name: "searched and missed",
+			msgs: []provider.Message{
+				recallCall("c1", `{"query":"unrelated words"}`),
+				toolResult("c1", hitBlock(3, 9)),
+			},
+			final: "not found",
+			want:  stageSearchMiss,
+		},
+		{
+			name: "found it and never opened it",
+			msgs: []provider.Message{
+				recallCall("c1", `{"query":"retry boundary"}`),
+				toolResult("c1", hitBlock(scorerTarget)),
+			},
+			final: "probably something about retries",
+			want:  stageHitNotRead,
+		},
+		{
+			name: "read it and answered wrong",
+			msgs: []provider.Message{
+				recallCall("c1", fmt.Sprintf(`{"positions":[%d]}`, scorerTarget)),
+				toolResult("c1", "#42\nthe token is elsewhere"),
+			},
+			final: "I think it was amber-9",
+			want:  stageAnswerWrong,
+		},
+		{
+			name: "read the wrong position",
+			msgs: []provider.Message{
+				recallCall("c1", `{"positions":[7]}`),
+				toolResult("c1", "#7\nnothing useful"),
+			},
+			final: "unclear",
+			want:  stageReadMissed,
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := score(t, tc.msgs, tc.final).FailureStage; got != tc.want {
+				t.Errorf("stage = %q, want %q", got, tc.want)
+			}
+		})
+	}
+}
+
+// The answer lives only in folded history, so reaching for the workspace is a
+// strategy change worth seeing — including when it happens to work.
+func TestScorerRecordsWorkspaceEscapes(t *testing.T) {
+	m := score(t, []provider.Message{
+		{Role: provider.RoleAssistant, ToolCalls: []provider.ToolCall{
+			{ID: "g1", Name: "bash", Arguments: `{"command":"rg cobalt-lark"}`},
+			{ID: "g2", Name: "read_file", Arguments: `{"path":"notes.md"}`},
+		}},
+		{Role: provider.RoleAssistant, Content: "cobalt-lark-17"},
+	}, "cobalt-lark-17")
+
+	if len(m.UnexpectedWorkTools) != 2 {
+		t.Fatalf("escapes = %v, want bash and read_file", m.UnexpectedWorkTools)
+	}
+	if m.SearchCalls != 0 || m.ReadCalls != 0 {
+		t.Errorf("a workspace tool was counted as recall: search=%d read=%d", m.SearchCalls, m.ReadCalls)
+	}
+	// It answered, so the run is Recovered — the escape is reported beside the
+	// outcome rather than overriding it.
+	if !m.AnswerRecovered {
+		t.Error("a correct answer was not scored as recovered")
+	}
+}
+
+// Narration is not action.
+func TestScorerIgnoresWhatTheModelSaysItWillDo(t *testing.T) {
+	m := score(t, []provider.Message{
+		{Role: provider.RoleAssistant, Content: "Let me search the folded context with recall for the retry boundary."},
+	}, "Let me search the folded context with recall for the retry boundary.")
+	if m.SearchCalls != 0 || m.FailureStage != stageNoRetrieval {
+		t.Errorf("prose was scored as a search: calls=%d stage=%q", m.SearchCalls, m.FailureStage)
+	}
+}
+
+// Every marker must land, so a partially right answer is not a recovery.
+func TestScorerRequiresEveryMarker(t *testing.T) {
+	task := fixtureInstance{Task: contextTask{ID: "t"}, AnswerMarkers: []string{"comet-42", "per-lineage"}}
+	m := scoreRun(nil, task, scorerTarget, "arm", false)
+	m.scoreAnswer("the salt was comet-42", task)
+	if m.AnswerRecovered {
+		t.Error("a half answer scored as recovered")
+	}
+	if len(m.MissingMarkers) != 1 || m.MissingMarkers[0] != "per-lineage" {
+		t.Errorf("missing = %v, want per-lineage", m.MissingMarkers)
+	}
+}
+
+// An answer reachable through anything but recall invalidates the run. The
+// workspace is isolated so this should never fire; asserting it beats trusting
+// it, and a tripped run leaves the statistics rather than inflating one.
+func TestScorerInvalidatesRunsThatLeakedThroughAnotherTool(t *testing.T) {
+	m := score(t, []provider.Message{
+		{Role: provider.RoleAssistant, ToolCalls: []provider.ToolCall{
+			{ID: "g1", Name: "bash", Arguments: `{"command":"rg -r ."}`},
+		}},
+		{Role: provider.RoleTool, ToolCallID: "g1", Name: "bash", Content: "corpus.go: the token is cobalt-lark-17"},
+		{Role: provider.RoleAssistant, Content: "cobalt-lark-17"},
+	}, "cobalt-lark-17")
+
+	if !m.Contaminated || m.LeakedVia != "bash" || m.LeakedMarker != "cobalt-lark-17" {
+		t.Fatalf("leak not caught: contaminated=%v via=%q marker=%q", m.Contaminated, m.LeakedVia, m.LeakedMarker)
+	}
+	if m.FailureStage != stageContaminated {
+		t.Errorf("stage = %q, want %q even though every marker matched", m.FailureStage, stageContaminated)
+	}
+	f := summarize("arm", []contextMetrics{m})
+	if f.Scored != 0 || f.Answered != 0 || f.Contaminated != 1 {
+		t.Errorf("a contaminated run entered the statistics: %+v", f)
+	}
+}
+
+// Where an escape happened matters: before any recall is a different strategy
+// from after one came back short.
+func TestScorerPlacesEscapesRelativeToRecall(t *testing.T) {
+	m := score(t, []provider.Message{
+		{Role: provider.RoleAssistant, ToolCalls: []provider.ToolCall{
+			{ID: "g1", Name: "bash", Arguments: `{"command":"ls"}`},
+		}},
+		{Role: provider.RoleTool, ToolCallID: "g1", Name: "bash", Content: "README.md"},
+		recallCall("c1", `{"query":"retry boundary"}`),
+		toolResult("c1", hitBlock(scorerTarget)),
+		{Role: provider.RoleAssistant, ToolCalls: []provider.ToolCall{
+			{ID: "g2", Name: "read_file", Arguments: `{"path":"README.md"}`},
+		}},
+		{Role: provider.RoleTool, ToolCallID: "g2", Name: "read_file", Content: "nothing here"},
+	}, "unclear")
+
+	if m.EscapeCalls != 2 || m.EscapeBeforeFirstRecall != 1 || m.EscapeAfterFirstRecall != 1 {
+		t.Errorf("escapes = %d (%d before, %d after), want 2 (1, 1)",
+			m.EscapeCalls, m.EscapeBeforeFirstRecall, m.EscapeAfterFirstRecall)
+	}
+}
+
+// Routing is judged by round. Two calls in one round are a fan-out, and
+// reporting that as a preference would invent a decision the model never made.
+func TestRoutingIsJudgedByRoundNotEventOrder(t *testing.T) {
+	parallel := []provider.Message{
+		{Role: provider.RoleAssistant, ToolCalls: []provider.ToolCall{
+			{ID: "g1", Name: "bash", Arguments: `{"command":"ls"}`},
+			{ID: "c1", Name: "recall", Arguments: `{"query":"retry boundary"}`},
+		}},
+		{Role: provider.RoleTool, ToolCallID: "g1", Name: "bash", Content: "README.md"},
+		toolResult("c1", hitBlock(scorerTarget)),
+	}
+	if got := score(t, parallel, "unclear").Routing; got != routeParallel {
+		t.Errorf("routing = %q for one round holding both, want %q", got, routeParallel)
+	}
+
+	workspaceFirst := []provider.Message{
+		{Role: provider.RoleAssistant, ToolCalls: []provider.ToolCall{
+			{ID: "g1", Name: "bash", Arguments: `{"command":"ls"}`},
+		}},
+		{Role: provider.RoleTool, ToolCallID: "g1", Name: "bash", Content: "README.md"},
+		recallCall("c1", `{"query":"retry boundary"}`),
+		toolResult("c1", hitBlock(scorerTarget)),
+	}
+	if got := score(t, workspaceFirst, "unclear").Routing; got != routeWorkspaceFirst {
+		t.Errorf("routing = %q for workspace in an earlier round, want %q", got, routeWorkspaceFirst)
+	}
+
+	memoryFirst := []provider.Message{
+		recallCall("c1", `{"query":"retry boundary"}`),
+		toolResult("c1", hitBlock(scorerTarget)),
+		{Role: provider.RoleAssistant, ToolCalls: []provider.ToolCall{
+			{ID: "g1", Name: "bash", Arguments: `{"command":"ls"}`},
+		}},
+		{Role: provider.RoleTool, ToolCallID: "g1", Name: "bash", Content: "README.md"},
+	}
+	if got := score(t, memoryFirst, "unclear").Routing; got != routeMemoryFirst {
+		t.Errorf("routing = %q for recall in an earlier round, want %q", got, routeMemoryFirst)
+	}
+
+	if got := score(t, nil, "no idea").Routing; got != routeNeither {
+		t.Errorf("routing = %q with no tools at all, want %q", got, routeNeither)
+	}
+}
+
+// Markers matching proves the right fact appears somewhere. An answer that
+// hedges between two candidates contains it and has not submitted it.
+func TestScorerFlagsAnAnswerThatNamesTwoCandidates(t *testing.T) {
+	inst := fixtureInstance{
+		Task:          contextTask{ID: "t", Vars: []varSpec{code("marker", "fence")}},
+		AnswerMarkers: []string{"fence-qmwnv"},
+	}
+	m := scoreRun(nil, inst, 0, "arm", false)
+	m.scoreAnswer("It was fence-qmwnv, though it may have been fence-abcde.", inst)
+	if !m.AnswerRecovered {
+		t.Error("the marker is present; recovery should still read true")
+	}
+	if !m.AnswerAmbiguous || m.AmbiguousVar != "marker" {
+		t.Errorf("ambiguity not flagged: %v %q", m.AnswerAmbiguous, m.AmbiguousVar)
+	}
+
+	clean := scoreRun(nil, inst, 0, "arm", false)
+	clean.scoreAnswer("The marker was fence-qmwnv.", inst)
+	if clean.AnswerAmbiguous {
+		t.Error("a single candidate was called ambiguous")
+	}
+}
+
+// The index arm's claim is narrow: the cue was addressed, the first memory
+// action was a positions read, and it covered the target. A positions call
+// after a search located the target credits the index for the search's work.
+func TestCueDirectReadRequiresTheCueAndTheFirstAction(t *testing.T) {
+	direct := []provider.Message{
+		recallCall("c1", fmt.Sprintf(`{"positions":[%d]}`, scorerTarget)),
+		toolResult("c1", "#42\nthe token is cobalt-lark-17"),
+	}
+	m := scoreRun(direct, scorerTask(), scorerTarget, "arm", true)
+	if !m.CueDirectRead {
+		t.Error("a first-action read with the cue visible was not credited")
+	}
+
+	// Same read, but no cue was on screen to give the address.
+	if scoreRun(direct, scorerTask(), scorerTarget, "arm", false).CueDirectRead {
+		t.Error("a read was credited to a cue that was not visible")
+	}
+
+	// Same read, but a search found the address first.
+	afterSearch := append([]provider.Message{
+		recallCall("c0", `{"query":"retry boundary"}`),
+		toolResult("c0", hitBlock(scorerTarget)),
+	}, direct...)
+	if scoreRun(afterSearch, scorerTask(), scorerTarget, "arm", true).CueDirectRead {
+		t.Error("a read after a search was credited to the index")
+	}
+}

benchmarks/context-retrieval/corpus.go

@@ -0,0 +1,469 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"reasonix/internal/state/sessionstore"
+
+	"reasonix/internal/contract/provider"
+)
+
+// Synthetic history on purpose: an answer that exists in the workspace is
+// solvable by reading the workspace, which measures grep. Every answer is a
+// placeholder here and a value only inside one run.
+
+// experiment names which question a task belongs to.
+const (
+	experimentSearch = "search" // does search reach what no index addresses?
+	experimentIndex  = "index"  // what is an ambient address line worth?
+)
+
+// cueTier is the narrowest fold-index scale at which an index task's cue is
+// still addressed. Below it the model has to find the call without a hint.
+const (
+	tierQuarter = "quarter" // visible at default, half, quarter
+	tierHalf    = "half"    // visible at default, half
+	tierDefault = "default" // visible at default only
+)
+
+// role places an index task in the efficiency substrate or the stopping corpus.
+const (
+	roleEfficiency = "efficiency"
+	roleStopping   = "stopping"
+)
+
+// plantKind is how a task's target enters the transcript.
+const (
+	plantAssistant = "assistant" // the model's own account: never index-addressed
+	plantCall      = "call"      // a tool call and its result: always index-addressed
+)
+
+// contextTask is one recall question as a template. Nothing here is an answer.
+type contextTask struct {
+	ID         string
+	Experiment string
+	TargetKind string
+	Prompt     string
+	ProbeQuery string
+	// Vars declare the placeholders. AnswerVars name the ones a correct answer
+	// must contain, CueVar the one an index line carries.
+	Vars       []varSpec
+	AnswerVars []string
+	CueVar     string
+	CueTier    string
+	// Role is roleEfficiency or roleStopping; it decides the batch a task enters.
+	Role string
+	// PlantAfterGen ages the target: mergeFoldIndex trims from its oldest end,
+	// so what follows a cue decides which budget addresses it. Frozen, because
+	// a run that searched for it would let the tested code move its goalposts.
+	PlantAfterGen int
+	// Plant is how the target enters, and the rest is what it says.
+	Plant     string
+	CallTool  string
+	CallArgs  string
+	CallID    string
+	PlantBody string
+}
+
+// fixtureInstance is one task with values. Scoring binds to this, never to the
+// corpus: the corpus has no answers to bind to.
+type fixtureInstance struct {
+	Task          contextTask
+	Vars          fixtureVars
+	Prompt        string
+	ProbeQuery    string
+	AnswerMarkers []string
+	CueMarker     string
+	body          string
+	callArgs      string
+}
+
+// instantiateTask resolves one task against a generator.
+func instantiateTask(t contextTask, rng *rand.Rand) (fixtureInstance, error) {
+	vars := newVars(t.Vars, rng)
+	inst := fixtureInstance{Task: t, Vars: vars}
+	var err error
+	for _, pair := range []struct {
+		dst  *string
+		text string
+	}{
+		{&inst.Prompt, t.Prompt},
+		{&inst.ProbeQuery, t.ProbeQuery},
+		{&inst.body, t.PlantBody},
+		{&inst.callArgs, t.CallArgs},
+	} {
+		if *pair.dst, err = instantiate(pair.text, vars); err != nil {
+			return fixtureInstance{}, fmt.Errorf("%s: %w", t.ID, err)
+		}
+	}
+	for _, name := range t.AnswerVars {
+		value, ok := vars[name]
+		if !ok {
+			return fixtureInstance{}, fmt.Errorf("%s: answer var %q is not declared", t.ID, name)
+		}
+		inst.AnswerMarkers = append(inst.AnswerMarkers, value)
+	}
+	if t.CueVar != "" {
+		inst.CueMarker = vars[t.CueVar]
+	}
+	return inst, nil
+}
+
+// plant appends the instantiated target and returns its canonical position.
+func (f fixtureInstance) plant(s *sessionstore.Session) int {
+	at := len(s.Messages)
+	if f.Task.Plant == plantAssistant {
+		s.Add(provider.Message{Role: provider.RoleAssistant, Content: f.body})
+		return at
+	}
+	s.Add(provider.Message{Role: provider.RoleAssistant, ToolCalls: []provider.ToolCall{
+		{ID: f.Task.CallID, Name: f.Task.CallTool, Arguments: f.callArgs},
+	}})
+	s.Add(provider.Message{Role: provider.RoleTool, ToolCallID: f.Task.CallID, Name: f.Task.CallTool, Content: f.body})
+	return at
+}
+
+func code(name, word string) varSpec { return varSpec{Name: name, Kind: varCodename, Word: word} }
+
+func num(name string, lo, hi int) varSpec {
+	return varSpec{Name: name, Kind: varInt, Min: lo, Max: hi}
+}
+
+// efficiencyTasks is the substrate a study measures on. Every task in it
+// qualifies under the corpus bar; the stopping corpus is deliberately excluded,
+// because a task carrying post-sufficient stopping behaviour swamps the effect
+// an efficiency batch exists to measure.
+func efficiencyTasks() []contextTask {
+	var out []contextTask
+	for _, t := range indexTasks() {
+		if t.Role == roleEfficiency {
+			out = append(out, t)
+		}
+	}
+	return out
+}
+
+func searchTasks() []contextTask {
+	return []contextTask{
+		{
+			ID: "r01-retry-boundary", Experiment: experimentSearch, TargetKind: "assistant_reasoning",
+			Prompt:     "What ownership token did we settle on for the retry boundary, and under what tag did we file the reason for not moving retries above framing?",
+			ProbeQuery: "retry boundary ownership token framing",
+			Vars:       []varSpec{code("token", "cobalt"), code("reason", "stream")},
+			AnswerVars: []string{"token", "reason"},
+			Plant:      plantAssistant,
+			PlantBody: "The retry boundary remains at ingress. The ownership token is {{token}}. " +
+				"Moving retries above framing can duplicate a partially received stream, which we filed as {{reason}}.",
+		},
+		{
+			ID: "r02-checkpoint-anchor", Experiment: experimentSearch, TargetKind: "assistant_reasoning",
+			Prompt:     "What was the codename of the checkpoint anchor policy, and what tag did we give the reason for not anchoring against digest positions?",
+			ProbeQuery: "checkpoint anchor policy digest positions",
+			Vars:       []varSpec{code("policy", "northglass"), code("reason", "genlocal")},
+			AnswerVars: []string{"policy", "reason"},
+			Plant:      plantAssistant,
+			PlantBody: "The checkpoint anchor policy is {{policy}}. Digest positions are generation-local — " +
+				"filed as {{reason}} — so recovery must anchor against canonical state.",
+		},
+		{
+			ID: "r03-recovery-cjk", Experiment: experimentSearch, TargetKind: "assistant_reasoning_cjk",
+			Prompt:     "我们之前定的验证失败恢复策略代号叫什么？当时把“失败 digest 不能变成 baseline”这条登记在哪个标记下？",
+			ProbeQuery: "恢复策略 baseline digest 验证失败",
+			Vars:       []varSpec{code("policy", "songzhen"), code("rule", "trustbase")},
+			AnswerVars: []string{"policy", "rule"},
+			Plant:      plantAssistant,
+			PlantBody: "恢复策略代号是 {{policy}}。验证失败以后必须保留旧基线，不能把新的 digest 晋升为 baseline，" +
+				"因为失败证据不能成为后续比较的可信基准；这条规则登记为 {{rule}}。",
+		},
+		{
+			ID: "r04-lease-fence", Experiment: experimentSearch, TargetKind: "assistant_reasoning",
+			Prompt:     "那次 lease fence 检查报告的诊断标记是什么？expected 和 observed epoch 分别是多少？",
+			ProbeQuery: "lease fence writer epoch mismatch",
+			Vars: []varSpec{
+				code("marker", "fence"), num("expected", 400, 900), num("observed", 100, 399),
+			},
+			AnswerVars: []string{"marker", "expected", "observed"},
+			Plant:      plantAssistant,
+			PlantBody: "The lease fence check reported {{marker}}: expected writer epoch {{expected}}, " +
+				"observed {{observed}}. We left the fence in place.",
+		},
+		{
+			ID: "r05-schema-guard", Experiment: experimentSearch, TargetKind: "assistant_reasoning",
+			Prompt:     "当时 schema guard 报告的标记是什么，超预算多少 token？",
+			ProbeQuery: "schema guard provider visible surface budget",
+			Vars:       []varSpec{code("marker", "amber"), num("over", 120, 480)},
+			AnswerVars: []string{"marker", "over"},
+			Plant:      plantAssistant,
+			PlantBody: "The schema guard reported {{marker}}: the provider-visible tool schema exceeded " +
+				"the allowed surface by {{over}} tokens. We trimmed a description instead.",
+		},
+		{
+			ID: "r06-shadow-probe", Experiment: experimentSearch, TargetKind: "assistant_reasoning",
+			Prompt:     "我们那次 shadow probe 的 marker、p95 divergence 和 generation 分别是多少？",
+			ProbeQuery: "shadow probe divergence generation marker",
+			Vars: []varSpec{
+				code("marker", "violet"),
+				{Name: "divergence", Kind: varDecimal, Min: 110, Max: 890},
+				num("generation", 14, 60),
+			},
+			AnswerVars: []string{"marker", "divergence", "generation"},
+			Plant:      plantAssistant,
+			PlantBody: "The shadow probe came back as marker={{marker}} with a p95 divergence of " +
+				"{{divergence}} at generation={{generation}}, which we judged within tolerance.",
+		},
+	}
+}
+
+// efficiencyIndexTasks is what a study measures on: two tasks per cue tier.
+func efficiencyIndexTasks() []contextTask {
+	out := indexQuarterTasks()
+	out = append(out, indexHalfTasks()...)
+	out = append(out, indexDefaultTasks()...)
+	return out
+}
+
+// indexQuarterTasks holds the quarter-tier literals.
+func indexQuarterTasks() []contextTask {
+	return []contextTask{
+		{
+			ID: "i37-dispatchlag", Experiment: experimentIndex, TargetKind: "tool_input", Role: roleEfficiency,
+			Prompt:     "早前会话里执行过 ./scripts/dispatchlag，它打印出的 dispatch lag epoch 是多少？",
+			ProbeQuery: "dispatchlag dispatch lag epoch",
+			Vars:       []varSpec{code("cue", "dispatchlag"), code("epoch", "cobalt")},
+			AnswerVars: []string{"epoch"}, CueVar: "cue", CueTier: tierQuarter,
+			PlantAfterGen: 4,
+			Plant:         plantCall, CallID: "p37", CallTool: "bash",
+			CallArgs:  `{"command":"./scripts/dispatchlag {{cue}}"}`,
+			PlantBody: "dispatch lag epoch = {{epoch}}",
+		},
+		{
+			ID: "i118-fencelag", Experiment: experimentIndex, TargetKind: "tool_input", Role: roleEfficiency,
+			Prompt:     "早前会话里运行过 ./scripts/fencelag，它打印出的 fence lag 是多少？",
+			ProbeQuery: "fencelag fence lag",
+			Vars:       []varSpec{code("cue", "fencelag"), code("v", "slate")},
+			AnswerVars: []string{"v"}, CueVar: "cue", CueTier: tierQuarter,
+			PlantAfterGen: 4,
+			Plant:         plantCall, CallID: "x118", CallTool: "bash",
+			CallArgs:  `{"command":"./scripts/fencelag {{cue}}"}`,
+			PlantBody: "fence lag = {{v}}",
+		},
+	}
+}
+
+// indexHalfTasks holds the half-tier literals.
+func indexHalfTasks() []contextTask {
+	return []contextTask{
+		{
+			ID: "i70-ingestfloor", Experiment: experimentIndex, TargetKind: "tool_input", Role: roleEfficiency,
+			Prompt:     "早前会话里执行过 ./scripts/ingestfloor，它打印出的 route quota 是多少？",
+			ProbeQuery: "ingestfloor quota",
+			Vars:       []varSpec{code("cue", "ingestfloor"), num("quota", 1200, 9800)},
+			AnswerVars: []string{"quota"}, CueVar: "cue", CueTier: tierHalf,
+			PlantAfterGen: 2,
+			Plant:         plantCall, CallID: "q70", CallTool: "bash",
+			CallArgs:  `{"command":"./scripts/ingestfloor {{cue}}"}`,
+			PlantBody: "route quota = {{quota}}",
+		},
+		{
+			ID: "i106-budgetseal", Experiment: experimentIndex, TargetKind: "tool_input", Role: roleEfficiency,
+			Prompt:     "早前会话里执行过 ./scripts/budgetseal，它打印出的 route quota 是多少？",
+			ProbeQuery: "budgetseal route quota",
+			Vars:       []varSpec{code("cue", "budgetseal"), code("quota", "amber")},
+			AnswerVars: []string{"quota"}, CueVar: "cue", CueTier: tierHalf,
+			PlantAfterGen: 2,
+			Plant:         plantCall, CallID: "h106", CallTool: "bash",
+			CallArgs:  `{"command":"./scripts/budgetseal {{cue}}"}`,
+			PlantBody: "route quota = {{quota}}",
+		},
+	}
+}
+
+// indexDefaultTasks holds the default-tier literals.
+func indexDefaultTasks() []contextTask {
+	return []contextTask{
+		{
+			ID: "i47-tenantlease", Experiment: experimentIndex, TargetKind: "tool_input", Role: roleEfficiency,
+			Prompt:     "早前会话里执行过 ./scripts/tenantlease，它打印出的 tenant lease（秒）是多少？",
+			ProbeQuery: "tenantlease tenant lease",
+			Vars:       []varSpec{code("cue", "tenantlease"), {Name: "lease", Kind: varDuration, Min: 15, Max: 300}},
+			AnswerVars: []string{"lease"}, CueVar: "cue", CueTier: tierDefault,
+			PlantAfterGen: 0,
+			Plant:         plantCall, CallID: "p47", CallTool: "bash",
+			CallArgs:  `{"command":"./scripts/tenantlease {{cue}}"}`,
+			PlantBody: "tenant lease = {{lease}}",
+		},
+		{
+			ID: "i112-lagquota", Experiment: experimentIndex, TargetKind: "tool_input", Role: roleEfficiency,
+			Prompt:     "早前会话里执行过 ./scripts/lagquota，它打印出的 lagquota lease 是多少？",
+			ProbeQuery: "lagquota lagquota lease",
+			Vars:       []varSpec{code("cue", "lagquota"), {Name: "lease", Kind: varDuration, Min: 20, Max: 420}},
+			AnswerVars: []string{"lease"}, CueVar: "cue", CueTier: tierDefault,
+			PlantAfterGen: 0,
+			Plant:         plantCall, CallID: "d112", CallTool: "bash",
+			CallArgs:  `{"command":"./scripts/lagquota {{cue}}"}`,
+			PlantBody: "lagquota lease = {{lease}}",
+		},
+	}
+}
+
+// stoppingIndexTasks is the frozen study's six tasks, kept out of efficiency
+// batches and measurable on their own with -task <id>.
+func stoppingIndexTasks() []contextTask {
+	return []contextTask{
+		{
+			ID: "i01-transport-fallback", Experiment: experimentIndex, TargetKind: "tool_input", Role: roleStopping,
+			Prompt:     "transport fallback probe 当时报告的 selector 是什么？",
+			ProbeQuery: "transport fallback probe selector",
+			Vars:       []varSpec{code("cue", "tfprobe"), code("selector", "fern")},
+			AnswerVars: []string{"selector"}, CueVar: "cue", CueTier: tierQuarter,
+			PlantAfterGen: 4,
+			Plant:         plantCall, CallID: "tf1", CallTool: "bash",
+			CallArgs:  `{"command":"./scripts/probe {{cue}}"}`,
+			PlantBody: "fallback selector = {{selector}}",
+		},
+		{
+			ID: "i02-scheduler-handoff", Experiment: experimentIndex, TargetKind: "tool_input", Role: roleStopping,
+			Prompt:     "scheduler handoff 当时记录的 grace 和 marker 是什么？",
+			ProbeQuery: "scheduler handoff grace marker",
+			Vars: []varSpec{
+				code("cue", "schedhandoff"), code("marker", "opal"),
+				{Name: "grace", Kind: varDuration, Min: 18, Max: 90},
+			},
+			AnswerVars: []string{"grace", "marker"}, CueVar: "cue", CueTier: tierQuarter,
+			PlantAfterGen: 4,
+			Plant:         plantCall, CallID: "sh1", CallTool: "read_file",
+			CallArgs:  `{"path":"scratch/{{cue}}.txt"}`,
+			PlantBody: "handoff grace = {{grace}}\nmarker = {{marker}}",
+		},
+		{
+			ID: "i03-coalescing", Experiment: experimentIndex, TargetKind: "tool_input", Role: roleStopping,
+			Prompt:     "job completion 的 coalescing probe 最后记录的 window 和 marker 是多少？",
+			ProbeQuery: "coalescing policy completion window",
+			Vars: []varSpec{
+				code("cue", "coalescing"), code("marker", "cedar"),
+				{Name: "window", Kind: varDuration, Min: 40, Max: 140},
+			},
+			AnswerVars: []string{"window", "marker"}, CueVar: "cue", CueTier: tierHalf,
+			PlantAfterGen: 2,
+			Plant:         plantCall, CallID: "cp1", CallTool: "bash",
+			CallArgs:  `{"command":"grep {{cue}} scratch/job-notes.log"}`,
+			PlantBody: "completion coalesce window = {{window}}\nmarker = {{marker}}",
+		},
+		{
+			ID: "i04-recovery-fence", Experiment: experimentIndex, TargetKind: "tool_input", Role: roleStopping,
+			Prompt:     "recovery fence 那次检查报告的 marker 和两个 epoch 是什么？",
+			ProbeQuery: "recovery fence epoch check",
+			Vars: []varSpec{
+				code("cue", "recfence"), code("marker", "quartz"),
+				num("expected", 400, 900), num("observed", 100, 399),
+			},
+			AnswerVars: []string{"marker", "expected", "observed"}, CueVar: "cue", CueTier: tierHalf,
+			PlantAfterGen: 2,
+			Plant:         plantCall, CallID: "rf1", CallTool: "bash",
+			CallArgs:  `{"command":"./scripts/check {{cue}}"}`,
+			PlantBody: "{{marker}}\nexpected epoch {{expected}}\nobserved epoch {{observed}}",
+		},
+		{
+			ID: "i05-cache-probe", Experiment: experimentIndex, TargetKind: "tool_input", Role: roleStopping,
+			Prompt:     "cache probe 当时记录的 prefix salt 和 scope 是什么？",
+			ProbeQuery: "cache probe prefix salt scope",
+			Vars:       []varSpec{code("cue", "cacheprobe"), code("salt", "comet"), code("scope", "lineage")},
+			AnswerVars: []string{"salt", "scope"}, CueVar: "cue", CueTier: tierDefault,
+			PlantAfterGen: 0,
+			Plant:         plantCall, CallID: "cb1", CallTool: "read_file",
+			CallArgs:  `{"path":"scratch/{{cue}}.txt"}`,
+			PlantBody: "prefix salt = {{salt}}\nscope = {{scope}}",
+		},
+		{
+			ID: "i06-dispatch-handoff", Experiment: experimentIndex, TargetKind: "tool_input", Role: roleStopping,
+			Prompt:     "dispatch handoff probe 当时确认的 mode 和 marker 是什么？",
+			ProbeQuery: "dispatch handoff probe mode",
+			Vars:       []varSpec{code("cue", "dispatchhandoff"), code("mode", "trigger"), code("marker", "iris")},
+			AnswerVars: []string{"mode", "marker"}, CueVar: "cue", CueTier: tierDefault,
+			PlantAfterGen: 0,
+			Plant:         plantCall, CallID: "dh1", CallTool: "bash",
+			CallArgs:  `{"command":"./scripts/probe {{cue}}"}`,
+			PlantBody: "handoff mode = {{mode}}\nmarker = {{marker}}",
+		},
+	}
+}
+
+// indexTasks is the whole index corpus, the efficiency substrate first.
+func indexTasks() []contextTask {
+	out := efficiencyIndexTasks()
+	return append(out, stoppingIndexTasks()...)
+}
+
+func allTasks() []contextTask {
+	return append(searchTasks(), indexTasks()...)
+}
+
+func taskByID(id string) (contextTask, bool) {
+	for _, t := range allTasks() {
+		if t.ID == id {
+			return t, true
+		}
+	}
+	return contextTask{}, false
+}
+
+// tierScales is the fixture's contract: which arms must address a cue and
+// which must not. A policy change that moves a cue across a boundary fails
+// preflight rather than turning two arms into one experiment.
+func tierScales(tier string) (visible, hidden []string) {
+	switch tier {
+	case tierQuarter:
+		return []string{"default", "half", "quarter"}, []string{"off"}
+	case tierHalf:
+		return []string{"default", "half"}, []string{"quarter", "off"}
+	case tierDefault:
+		return []string{"default"}, []string{"half", "quarter", "off"}
+	default:
+		return nil, nil
+	}
+}
+
+// boundaryPair is the one comparison an index task is built for: the narrowest
+// scale that still addresses its cue, and the next one down. Holding the
+// question fixed and moving only the affordance is what four arm averages
+// cannot do, since each of those mixes six different questions.
+func boundaryPair(tier string) (cue, noCue string) {
+	switch tier {
+	case tierQuarter:
+		return "quarter", "off"
+	case tierHalf:
+		return "half", "quarter"
+	case tierDefault:
+		return "default", "half"
+	default:
+		return "", ""
+	}
+}
+
+func validateCorpus() error {
+	seen := map[string]bool{}
+	for _, t := range allTasks() {
+		if seen[t.ID] {
+			return fmt.Errorf("duplicate task id %q", t.ID)
+		}
+		seen[t.ID] = true
+		if len(t.AnswerVars) == 0 || t.ProbeQuery == "" || t.Prompt == "" || t.PlantBody == "" {
+			return fmt.Errorf("%s: a task needs a prompt, a probe query, a body and answer vars", t.ID)
+		}
+		if t.Experiment == experimentIndex {
+			if t.CueVar == "" {
+				return fmt.Errorf("%s: an index task needs a cue var", t.ID)
+			}
+			if t.Role != roleEfficiency && t.Role != roleStopping {
+				return fmt.Errorf("%s: an index task needs a role (%s or %s)", t.ID, roleEfficiency, roleStopping)
+			}
+			if v, _ := tierScales(t.CueTier); v == nil {
+				return fmt.Errorf("%s: unknown cue tier %q", t.ID, t.CueTier)
+			}
+		}
+		if _, err := instantiateTask(t, seededRand(t.ID, "validate")); err != nil {
+			return err
+		}
+	}
+	return nil
+}

benchmarks/context-retrieval/dose.go

@@ -0,0 +1,243 @@
+// dose.go — does the cost step where the cue disappears?
+package main
+
+import (
+	"fmt"
+	"math"
+	"sort"
+	"strings"
+)
+
+// Not "a bigger index is better" — CueDirectRead says the addresses are rarely
+// used. The hypothesis is that a visible action cue lowers retrieval cost,
+// which predicts a step at each task's own boundary, not a slope.
+
+// scaleOrder is the dose axis, widest first.
+var scaleOrder = []string{"default", "half", "quarter", "off"}
+
+// boundaryStep is the index into the three transitions where a tier's cue
+// disappears: default->half is 0, half->quarter is 1, quarter->off is 2.
+func boundaryStep(tier string) int {
+	switch tier {
+	case tierDefault:
+		return 0
+	case tierHalf:
+		return 1
+	case tierQuarter:
+		return 2
+	default:
+		return -1
+	}
+}
+
+// doseCurve is one task's readings across the four budgets.
+type doseCurve struct {
+	Task   string
+	Tier   string
+	Metric string
+	Values [4]float64
+	// Missing marks arms that produced nothing. Printing those as zero draws a
+	// curve falling to the floor where in fact it was never measured.
+	Missing [4]bool
+	Present bool
+	// PreMean averages the arms where the cue is visible, PostMean the rest.
+	PreMean, PostMean float64
+	BoundaryDelta     float64
+	// BoundaryAligned: the largest transition is the one where this task's cue
+	// disappears. A change elsewhere is variance shaped like an effect.
+	BoundaryAligned bool
+}
+
+func buildCurve(task, tier, metric string, byScale map[string]float64) doseCurve {
+	c := doseCurve{Task: task, Tier: tier, Metric: metric, Present: true}
+	for i, scale := range scaleOrder {
+		v, ok := byScale[scale]
+		if !ok {
+			c.Present, c.Missing[i] = false, true
+		}
+		c.Values[i] = v
+	}
+	step := boundaryStep(tier)
+	if !c.Present || step < 0 {
+		return c
+	}
+	visible := step + 1 // arms before the boundary still show the cue
+	c.PreMean = mean(c.Values[:visible])
+	c.PostMean = mean(c.Values[visible:])
+	c.BoundaryDelta = c.PostMean - c.PreMean
+
+	transitions := [3]float64{
+		math.Abs(c.Values[1] - c.Values[0]),
+		math.Abs(c.Values[2] - c.Values[1]),
+		math.Abs(c.Values[3] - c.Values[2]),
+	}
+	largest, at := 0.0, -1
+	for i, t := range transitions {
+		if t > largest {
+			largest, at = t, i
+		}
+	}
+	// A flat curve has no largest transition to align with anything.
+	c.BoundaryAligned = largest > 0 && at == step
+	return c
+}
+
+func mean(xs []float64) float64 {
+	if len(xs) == 0 {
+		return 0
+	}
+	sum := 0.0
+	for _, x := range xs {
+		sum += x
+	}
+	return sum / float64(len(xs))
+}
+
+func median(xs []float64) float64 {
+	if len(xs) == 0 {
+		return 0
+	}
+	s := append([]float64(nil), xs...)
+	sort.Float64s(s)
+	mid := len(s) / 2
+	if len(s)%2 == 1 {
+		return s[mid]
+	}
+	return (s[mid-1] + s[mid]) / 2
+}
+
+// doseMetrics are the readings a curve is drawn for.
+var doseMetrics = []struct {
+	name string
+	of   func(contextMetrics) float64
+}{
+	{"searches", func(m contextMetrics) float64 { return float64(m.SearchCalls) }},
+	{"recall-tokens", func(m contextMetrics) float64 { return float64(m.RecallReturnedTokens) }},
+	{"tool-rounds", func(m contextMetrics) float64 { return float64(m.RetrievalRounds + m.EscapeCalls) }},
+	{"escapes", func(m contextMetrics) float64 { return float64(m.EscapeCalls) }},
+}
+
+// reportDoseResponse draws each task's curve and reports where the steps fell.
+func reportDoseResponse(all []contextMetrics) string {
+	valid := map[string]map[string]contextMetrics{}
+	for _, m := range all {
+		if m.Contaminated || m.FailureStage == "RunError" {
+			continue
+		}
+		scale := strings.TrimPrefix(m.Arm, "index-")
+		if valid[m.Task] == nil {
+			valid[m.Task] = map[string]contextMetrics{}
+		}
+		valid[m.Task][scale] = m
+	}
+
+	var b strings.Builder
+	b.WriteString("\n## Dose-response, per task\n")
+	b.WriteString("  The arrow marks where this task's cue stops being addressed.\n")
+	aligned := map[string]int{}
+	counted := map[string]int{}
+	deltas := map[string][]float64{}
+
+	for _, t := range indexTasks() {
+		arms := valid[t.ID]
+		if len(arms) == 0 {
+			continue
+		}
+		step := boundaryStep(t.CueTier)
+		fmt.Fprintf(&b, "\n  %s (cue survives to %s)\n", t.ID, t.CueTier)
+		fmt.Fprintf(&b, "    %-14s%s\n", "", scaleHeader(step))
+		for _, metric := range doseMetrics {
+			byScale := map[string]float64{}
+			for scale, m := range arms {
+				byScale[scale] = metric.of(m)
+			}
+			c := buildCurve(t.ID, t.CueTier, metric.name, byScale)
+			mark := " "
+			if c.BoundaryAligned {
+				mark = "*"
+				aligned[metric.name]++
+			}
+			if c.Present {
+				counted[metric.name]++
+				deltas[metric.name] = append(deltas[metric.name], c.BoundaryDelta)
+			}
+			delta := fmt.Sprintf("Δ%+8.1f", c.BoundaryDelta)
+			if !c.Present {
+				delta = "  no curve"
+			}
+			fmt.Fprintf(&b, "    %-14s%s   %s %s\n", metric.name, curveCells(c), delta, mark)
+		}
+	}
+
+	b.WriteString("\n## Where the step fell (* = largest transition is at the cue boundary)\n")
+	for _, metric := range doseMetrics {
+		d := deltas[metric.name]
+		sensitivity := ""
+		if len(d) > 1 {
+			sensitivity = fmt.Sprintf("  without the largest: %+.1f", meanWithoutLargest(d))
+		}
+		fmt.Fprintf(&b, "  %-14s boundary-aligned %d/%d   mean Δ%+.1f   median Δ%+.1f%s\n",
+			metric.name, aligned[metric.name], counted[metric.name], mean(d), median(d), sensitivity)
+	}
+	return b.String()
+}
+
+// meanWithoutLargest is the robustness check: the largest effect is reported
+// and then set aside, so a conclusion never rests on one task alone.
+func meanWithoutLargest(d []float64) float64 {
+	if len(d) < 2 {
+		return mean(d)
+	}
+	worst, at := 0.0, 0
+	for i, v := range d {
+		if math.Abs(v) > worst {
+			worst, at = math.Abs(v), i
+		}
+	}
+	rest := append(append([]float64(nil), d[:at]...), d[at+1:]...)
+	return mean(rest)
+}
+
+func scaleHeader(step int) string {
+	var b strings.Builder
+	for i, s := range scaleOrder {
+		if i == step+1 {
+			s = "↓" + s
+		}
+		fmt.Fprintf(&b, "%8s", s)
+	}
+	return b.String()
+}
+
+// curveCells prints a reading per arm, and a dash where an arm produced none.
+func curveCells(c doseCurve) string {
+	var b strings.Builder
+	for i, v := range c.Values {
+		if c.Missing[i] {
+			fmt.Fprintf(&b, "%8s", "-")
+			continue
+		}
+		fmt.Fprintf(&b, "%8.0f", v)
+	}
+	return b.String()
+}
+
+func percentile(xs []float64, q float64) float64 {
+	if len(xs) == 0 {
+		return 0
+	}
+	s := append([]float64(nil), xs...)
+	sort.Float64s(s)
+	i := int(float64(len(s)-1) * q)
+	return s[i]
+}
+
+func maxOf(xs []float64) float64 {
+	out := 0.0
+	for _, x := range xs {
+		if x > out {
+			out = x
+		}
+	}
+	return out
+}

benchmarks/context-retrieval/fixture.go

@@ -0,0 +1,205 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"reasonix/internal/state/sessionstore"
+	"strings"
+
+	"reasonix/internal/contract/ablation"
+	"reasonix/internal/contract/event"
+	"reasonix/internal/contract/provider"
+	"reasonix/internal/contract/tool"
+	"reasonix/internal/runtime/agent"
+)
+
+// A fixture is a real session that has really been compacted: no bench-only
+// state shape, so the loader and the projection restore have to work on it.
+
+const (
+	fixtureWindow      = 60000
+	fixtureGenerations = 5
+	// fillerBytes per unit is what makes a fold necessary rather than optional.
+	fillerBytes = 6000
+)
+
+// digestProvider answers a summarizer without naming anything the corpus
+// plants. A digest that happened to quote the answer would leave it visible
+// and silently turn the task into a no-op.
+type digestProvider struct{ calls int }
+
+func (p *digestProvider) Name() string { return "fixture-digest" }
+
+func (p *digestProvider) Stream(_ context.Context, _ provider.Request) (<-chan provider.Chunk, error) {
+	p.calls++
+	ch := make(chan provider.Chunk, 2)
+	ch <- provider.Chunk{Type: provider.ChunkText, Text: "## Earlier work\nEarlier work continued across several files; nothing outstanding was recorded."}
+	ch <- provider.Chunk{Type: provider.ChunkDone}
+	close(ch)
+	return ch, nil
+}
+
+// fillerCall is one ordinary read whose only job is to take up room — in the
+// window, and in the fold index ahead of a cue.
+func fillerCall(sess *sessionstore.Session, n int) {
+	id := fmt.Sprintf("f%04d", n)
+	sess.Add(provider.Message{Role: provider.RoleAssistant, ToolCalls: []provider.ToolCall{
+		{ID: id, Name: "read_file", Arguments: fmt.Sprintf(`{"path":"internal/mod%03d/handler%03d.go"}`, n%37, n)},
+	}})
+	sess.Add(provider.Message{Role: provider.RoleTool, ToolCallID: id, Name: "read_file", Content: fillerBody(n)})
+}
+
+func fillerBody(n int) string {
+	var b strings.Builder
+	fmt.Fprintf(&b, "package mod%03d\n\n", n%37)
+	for b.Len() < fillerBytes {
+		fmt.Fprintf(&b, "func handler%03dStep%02d() error { return nil }\n", n, b.Len()%64)
+	}
+	return b.String()
+}
+
+// builtFixture is one task's history after real folds, plus where its target
+// ended up.
+type builtFixture struct {
+	Session  *sessionstore.Session
+	State    sessionstore.CompactionState
+	Target   int
+	Path     string
+	Instance fixtureInstance
+}
+
+// buildFixture plays a task's history through the real agent and folds it at
+// the given arm, writing the session and its context state where the agent
+// itself would.
+func buildFixture(f fixtureInstance, arm ablation.Set, sessionPath string) (builtFixture, error) {
+	t := f.Task
+	sess := sessionstore.NewSession("You are a coding agent.")
+	sess.Add(provider.Message{Role: provider.RoleUser, Content: "Work through the transport and scheduler backlog."})
+
+	n := 0
+	at := -1
+
+	a := agent.New(&digestProvider{}, tool.NewRegistry(), sess, agent.Options{
+		ContextWindow: fixtureWindow, CompactRatio: 0.5, RecentKeep: 2,
+		SessionPath: sessionPath, KeepPolicy: agent.KeepErrors, Ablation: arm,
+	}, event.Discard)
+
+	for gen := range fixtureGenerations {
+		if gen == t.PlantAfterGen {
+			at = f.plant(sess)
+		}
+		for range 8 {
+			fillerCall(sess, n)
+			n++
+		}
+		if _, err := a.CompactNow(context.Background(), agent.CompactRequest{}); err != nil {
+			return builtFixture{}, fmt.Errorf("%s: generation %d fold: %w", t.ID, gen, err)
+		}
+	}
+	if at < 0 {
+		return builtFixture{}, fmt.Errorf("%s: PlantAfterGen %d is past the last generation", t.ID, t.PlantAfterGen)
+	}
+	// projectionCoversTail cannot revalidate a projection covering the whole
+	// transcript: it needs a live tail, which a real session always has because
+	// work continues after a fold. Neutral text — the tail is provider-visible.
+	sess.Add(provider.Message{Role: provider.RoleAssistant, Content: "Backlog swept; ready for the next question."})
+	if err := sess.Save(sessionPath); err != nil {
+		return builtFixture{}, fmt.Errorf("%s: save session: %w", t.ID, err)
+	}
+	state, ok, err := sessionstore.LoadCompactionState(sessionPath)
+	if err != nil {
+		return builtFixture{}, fmt.Errorf("%s: load context state: %w", t.ID, err)
+	}
+	if !ok || len(state.Projection.Messages) == 0 {
+		return builtFixture{}, fmt.Errorf("%s: no projection was installed", t.ID)
+	}
+	if state.Projection.CoveredCount <= at {
+		return builtFixture{}, fmt.Errorf("%s: target #%d is not inside the folded region (covered %d)",
+			t.ID, at, state.Projection.CoveredCount)
+	}
+	return builtFixture{Session: sess, State: state, Target: at, Path: sessionPath, Instance: f}, nil
+}
+
+// visibleContext is the model-visible view: the stored projection spliced with
+// everything canonical that came after it.
+func visibleContext(f builtFixture) []provider.Message {
+	canonical := f.Session.Snapshot()
+	out := append([]provider.Message(nil), f.State.Projection.Messages...)
+	if n := f.State.Projection.CoveredCount; n >= 0 && n < len(canonical) {
+		out = append(out, canonical[n:]...)
+	}
+	return out
+}
+
+// visibleText is everything the model would read, as one string.
+func visibleText(f builtFixture) string {
+	var b strings.Builder
+	for _, m := range visibleContext(f) {
+		b.WriteString(m.Content)
+		b.WriteString("\n")
+		for _, tc := range m.ToolCalls {
+			b.WriteString(tc.Name)
+			b.WriteString(" ")
+			b.WriteString(string(tc.Arguments))
+			b.WriteString("\n")
+		}
+	}
+	return b.String()
+}
+
+// sealFixture removes the fixture from disk once the agent holds it in memory.
+// The canonical transcript is the answer, and the sandbox mounts the host
+// read-only by design — so a model that finds the path reads the answer, which
+// one did. The agent has already loaded the session and its sidecar by the time
+// this runs; a failed autosave afterwards costs the benchmark nothing.
+func sealFixture(sessionPath string) {
+	// Every file, not two named ones: a session writes an event log and a
+	// context sidecar beside the transcript, and session.events.jsonl still
+	// carried the answer after the other two were sealed by name.
+	dir := filepath.Dir(sessionPath)
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return
+	}
+	for _, e := range entries {
+		if !e.IsDir() {
+			_ = os.Remove(filepath.Join(dir, e.Name()))
+		}
+	}
+	// Deny the directory too, so an autosave cannot recreate what was removed.
+	_ = os.Chmod(dir, 0o500)
+}
+
+// unsealFixture restores the directory so the harness can clean up after
+// itself.
+func unsealFixture(sessionPath string) {
+	_ = os.Chmod(filepath.Dir(sessionPath), 0o700)
+}
+
+// answerOnDisk reports any readable file under dir holding a current-run
+// answer. Two named files were sealed because two leaks were found in them;
+// this scans the directory, so a path that moves — an autosave, a recovery
+// tombstone, a future sidecar — fails here instead of on a paid run.
+func answerOnDisk(dir string, markers []string) (string, string) {
+	var atPath, found string
+	_ = filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
+		if err != nil || d.IsDir() || atPath != "" {
+			return nil //nolint:nilerr // an unreadable entry is not a leak
+		}
+		body, readErr := os.ReadFile(path)
+		if readErr != nil {
+			return nil
+		}
+		for _, marker := range markers {
+			if len(marker) >= 6 && strings.Contains(string(body), marker) {
+				atPath, found = path, marker
+				return filepath.SkipAll
+			}
+		}
+		return nil
+	})
+	return atPath, found
+}

benchmarks/context-retrieval/instance.go

@@ -0,0 +1,139 @@
+// instance.go — a task template becomes one run's concrete history.
+package main
+
+import (
+	"crypto/rand"
+	"fmt"
+	"hash/fnv"
+	"io"
+	mathrand "math/rand"
+	"strings"
+)
+
+// The invariant this file exists for: no literal sufficient to satisfy
+// AnswerRecovered for a concrete run may exist in this repository before that
+// run begins. Grepping the corpus reveals the question, never the answer.
+
+// varKind is how one placeholder's value is generated. Values stay shaped like
+// real engineering records — a UUID would defeat the leak but turn every task
+// into "find the random string".
+type varKind string
+
+const (
+	varCodename varKind = "codename" // cobalt-k7m4q9
+	varInt      varKind = "int"      // 731
+	varDecimal  varKind = "decimal"  // 0.0437
+	varDuration varKind = "duration" // 43ms
+)
+
+// varSpec declares one placeholder. Min/Max bound the numeric kinds.
+type varSpec struct {
+	Name string
+	Kind varKind
+	Word string // codename stem, e.g. "cobalt"
+	Min  int
+	Max  int
+}
+
+// codenameEntropy is how much of a codename is unguessable. Five base32 digits
+// is about 25 bits: far past what a model can reach by knowing the stem.
+const codenameEntropy = 5
+
+const codenameAlphabet = "abcdefghijkmnpqrstuvwxyz23456789"
+
+// fixtureVars is one run's instantiated values.
+type fixtureVars map[string]string
+
+// newVars generates values for every spec. A nil rng means deterministic.
+func newVars(specs []varSpec, rng *mathrand.Rand) fixtureVars {
+	out := fixtureVars{}
+	for _, spec := range specs {
+		switch spec.Kind {
+		case varCodename:
+			out[spec.Name] = spec.Word + "-" + randomToken(rng, codenameEntropy)
+		case varInt:
+			out[spec.Name] = fmt.Sprint(randomBetween(rng, spec.Min, spec.Max))
+		case varDecimal:
+			out[spec.Name] = fmt.Sprintf("0.%04d", randomBetween(rng, spec.Min, spec.Max))
+		case varDuration:
+			out[spec.Name] = fmt.Sprintf("%dms", randomBetween(rng, spec.Min, spec.Max))
+		}
+	}
+	return out
+}
+
+func randomToken(rng *mathrand.Rand, n int) string {
+	var b strings.Builder
+	for range n {
+		b.WriteByte(codenameAlphabet[randomBetween(rng, 0, len(codenameAlphabet)-1)])
+	}
+	return b.String()
+}
+
+func randomBetween(rng *mathrand.Rand, lo, hi int) int {
+	if hi <= lo {
+		return lo
+	}
+	return lo + rng.Intn(hi-lo+1)
+}
+
+// seededRand is the deterministic generator preflight and tests use, so a
+// fixture's tier calibration and its golden state reproduce exactly.
+func seededRand(parts ...string) *mathrand.Rand {
+	h := fnv.New64a()
+	for _, p := range parts {
+		h.Write([]byte(p))
+		h.Write([]byte{0})
+	}
+	return mathrand.New(mathrand.NewSource(int64(h.Sum64())))
+}
+
+// liveRand is the generator a paid run uses: every run gets values that existed
+// nowhere before it started.
+func liveRand() *mathrand.Rand {
+	rng, err := liveRandFrom(rand.Reader)
+	if err != nil {
+		panic("contextbench: no entropy for a live run: " + err.Error())
+	}
+	return rng
+}
+
+// liveRandFrom seeds a generator from an entropy source, so what a run's values
+// are unpredictable from is the source and nothing else.
+func liveRandFrom(entropy io.Reader) (*mathrand.Rand, error) {
+	var seed [8]byte
+	if _, err := io.ReadFull(entropy, seed[:]); err != nil {
+		return nil, err
+	}
+	var n int64
+	for _, b := range seed {
+		n = n<<8 | int64(b)
+	}
+	return mathrand.New(mathrand.NewSource(n)), nil
+}
+
+// instantiate substitutes {{name}} and refuses anything left over. The grammar
+// is one identifier in double braces: no conditionals, no loops, no defaults.
+// This is fixture data, not a template language.
+func instantiate(text string, vars fixtureVars) (string, error) {
+	out := text
+	for name, value := range vars {
+		out = strings.ReplaceAll(out, "{{"+name+"}}", value)
+	}
+	if strings.Contains(out, "{{") || strings.Contains(out, "}}") {
+		return "", fmt.Errorf("unresolved placeholder in %q", firstPlaceholder(out))
+	}
+	return out, nil
+}
+
+func firstPlaceholder(text string) string {
+	i := strings.Index(text, "{{")
+	if i < 0 {
+		return text
+	}
+	j := strings.Index(text[i:], "}}")
+	if j < 0 {
+		return text[i:min(i+40, len(text))]
+	}
+	return text[i : i+j+2]
+}

benchmarks/context-retrieval/main.go

@@ -0,0 +1,144 @@
+// ContextRetrievalBench builds the fixtures the long-horizon retrieval
+// experiments run against, and proves they are worth paying a provider for.
+//
+//	-mode=calibrate  find each index task's lead-call count for its cue tier
+//	-mode=preflight  build every task under every arm and check the contract
+//
+// Nothing here calls a provider. The experiments themselves do; this is what
+// says they would measure what they claim to.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+)
+
+func main() {
+	mode := flag.String("mode", "preflight", "calibrate | preflight | snippet | adversarial | run-search | run-boundary | run-index")
+	work := flag.String("work", "", "directory for built fixtures (default: a temp dir)")
+	only := flag.String("task", "", "limit to one task id")
+	dry := flag.Bool("dry", false, "run modes: drive the pipeline with a scripted provider instead of paying for one")
+	flag.Parse()
+
+	if err := validateCorpus(); err != nil {
+		fmt.Fprintln(os.Stderr, "corpus:", err)
+		os.Exit(2)
+	}
+	root := *work
+	if root == "" {
+		dir, err := os.MkdirTemp("", "context-retrieval-*")
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(2)
+		}
+		defer os.RemoveAll(dir)
+		root = dir
+	}
+
+	tasks := allTasks()
+	if *only != "" {
+		t, ok := taskByID(*only)
+		if !ok {
+			fmt.Fprintf(os.Stderr, "unknown task %q\n", *only)
+			os.Exit(2)
+		}
+		tasks = []contextTask{t}
+	}
+
+	switch *mode {
+	case "calibrate":
+		os.Exit(runCalibrate(tasks, root))
+	case "preflight":
+		os.Exit(runPreflight(tasks, root))
+	case "run-search":
+		os.Exit(runExperiment(experimentSearch, root, *dry, tasks))
+	case "run-boundary":
+		os.Exit(runBoundaries(root))
+	case "snippet":
+		os.Exit(runSnippetAudit(root, 100))
+	case "adversarial":
+		os.Exit(runAdversarial(root))
+	case "run-index":
+		batch := tasks
+		if *only == "" {
+			// A batch measures the efficiency substrate only. Naming one task
+			// with -task runs that task, role included, so the stopping corpus
+			// stays measurable on its own.
+			batch = efficiencyTasks()
+		}
+		os.Exit(runExperiment(experimentIndex, root, *dry, batch))
+	default:
+		fmt.Fprintf(os.Stderr, "unknown mode %q\n", *mode)
+		os.Exit(2)
+	}
+}
+
+func runPreflight(tasks []contextTask, root string) int {
+	var all []finding
+	for _, t := range tasks {
+		found, err := checkTask(t, root)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "%s: %v\n", t.ID, err)
+			return 2
+		}
+		all = append(all, found...)
+		status := "ok"
+		if len(found) > 0 {
+			status = fmt.Sprintf("%d problem(s)", len(found))
+		}
+		fmt.Printf("%-24s %-6s gen=%-2d %s\n", t.ID, t.Experiment, t.PlantAfterGen, status)
+	}
+	if len(all) == 0 {
+		fmt.Printf("\n%d fixtures ready.\n", len(tasks))
+		return 0
+	}
+	fmt.Fprintf(os.Stderr, "\n%d preflight problem(s):\n", len(all))
+	sort.Slice(all, func(i, j int) bool { return all[i].Task < all[j].Task })
+	for _, f := range all {
+		fmt.Fprintln(os.Stderr, " ", f)
+	}
+	return 1
+}
+
+// runCalibrate reports, for each index task, the lead-call counts at which its
+// cue is still addressed by each budget. The corpus freezes one number from
+// this; it is never computed at run time, or the implementation under test
+// would be moving its own goalposts.
+func runCalibrate(tasks []contextTask, root string) int {
+	for _, t := range tasks {
+		if t.Experiment != experimentIndex {
+			continue
+		}
+		var rows []string
+		for lead := range fixtureGenerations {
+			probe := t
+			probe.PlantAfterGen = lead
+			var visibleAt []string
+			for _, scale := range armScales {
+				inst, ierr := instantiateTask(probe, seededRand(t.ID, scale, "calibrate"))
+				if ierr != nil {
+					fmt.Fprintln(os.Stderr, ierr)
+					return 2
+				}
+				f, err := buildFixture(inst, armFor(scale, false),
+					fmt.Sprintf("%s/calib/%s/%d-%s/session.jsonl", root, t.ID, lead, scale))
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "%s gen=%d %s: %v\n", t.ID, lead, scale, err)
+					return 2
+				}
+				if strings.Contains(visibleText(f), inst.CueMarker) {
+					visibleAt = append(visibleAt, scale)
+				}
+			}
+			rows = append(rows, fmt.Sprintf("planted after gen %d, cue visible at: %s", lead, strings.Join(visibleAt, ",")))
+		}
+		fmt.Printf("\n%s (wants tier %s)\n", t.ID, t.CueTier)
+		for _, r := range rows {
+			fmt.Println(" ", r)
+		}
+	}
+	return 0
+}

benchmarks/context-retrieval/main_test.go

@@ -0,0 +1,189 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"maps"
+	mathrand "math/rand"
+	"os/exec"
+	"slices"
+	"strings"
+	"testing"
+)
+
+// The same checks the preflight mode runs, under go test: a compaction change
+// that invalidates the fixtures fails here rather than three hundred API calls
+// later.
+
+func TestCorpusIsWellFormed(t *testing.T) {
+	if err := validateCorpus(); err != nil {
+		t.Fatal(err)
+	}
+	if got := len(searchTasks()); got != 6 {
+		t.Errorf("search experiment has %d tasks, want 6", got)
+	}
+	if got := len(indexTasks()); got != 12 {
+		t.Errorf("index experiment has %d tasks, want 12", got)
+	}
+	stopping := map[string]bool{}
+	tiers := map[string]int{}
+	for _, task := range indexTasks() {
+		if task.Role == roleStopping {
+			stopping[task.ID] = true
+			continue
+		}
+		tiers[task.CueTier]++
+	}
+	if !stopping["i03-coalescing"] || !stopping["i04-recovery-fence"] {
+		t.Errorf("the stopping corpus is %v; it must keep i03-coalescing and i04-recovery-fence", stopping)
+	}
+	// Two per tier, over the efficiency substrate, is what makes the staircase
+	// readable: the same task can be compared across the boundary its cue sits
+	// on, instead of two different questions being compared across two arms.
+	for _, tier := range []string{tierQuarter, tierHalf, tierDefault} {
+		if tiers[tier] != 2 {
+			t.Errorf("tier %s has %d tasks, want 2", tier, tiers[tier])
+		}
+	}
+}
+
+// The role decides which batch a task enters; the literal lists are only where
+// it is declared, so the two must not drift.
+func TestIndexListsMatchTheirRoles(t *testing.T) {
+	for _, task := range append(append(indexQuarterTasks(), indexHalfTasks()...), indexDefaultTasks()...) {
+		if task.Role != roleEfficiency {
+			t.Errorf("%s sits in an efficiency list with role %q", task.ID, task.Role)
+		}
+	}
+	for _, task := range stoppingIndexTasks() {
+		if task.Role != roleStopping {
+			t.Errorf("%s sits in the stopping list with role %q", task.ID, task.Role)
+		}
+	}
+}
+
+// The invariant the whole instantiation layer exists for: no literal a scorer
+// needs may be readable in this repository before a run starts.
+func TestNoAnswerLiteralExistsInTheRepository(t *testing.T) {
+	root, err := repoRoot()
+	if err != nil {
+		t.Skip(err)
+	}
+	for _, task := range allTasks() {
+		inst, err := instantiateTask(task, seededRand(task.ID, "leak-check"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, marker := range append(inst.AnswerMarkers, inst.CueMarker) {
+			if len(marker) < 6 {
+				continue // a bare number is not a literal anyone can grep for
+			}
+			if found, where := grepRepo(t, root, marker); found {
+				t.Errorf("%s: %q is readable at %s before the run", task.ID, marker, where)
+			}
+		}
+	}
+}
+
+// A run's values are unpredictable from a previous run only if the live
+// generator is seeded from entropy. Comparing answers across two instances
+// cannot assert that: a task whose answer is a bounded number collides by
+// chance (1/8601 to 1/286 per task), so the check is on the seed source.
+func TestLiveRandDrawsFromEntropy(t *testing.T) {
+	a, b := liveRand(), liveRand()
+	for range 4 {
+		if a.Int63() != b.Int63() {
+			return
+		}
+	}
+	t.Fatal("two live generators produced the same stream: they are seeded alike")
+}
+
+// The source alone decides an instance: the same entropy gives the same
+// answers, different entropy gives different values.
+func TestLiveRandSourceDecidesTheInstance(t *testing.T) {
+	same := func() *mathrand.Rand {
+		rng, err := liveRandFrom(bytes.NewReader(bytes.Repeat([]byte{7}, 8)))
+		if err != nil {
+			t.Fatal(err)
+		}
+		return rng
+	}
+	other, err := liveRandFrom(bytes.NewReader(bytes.Repeat([]byte{9}, 8)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := liveRandFrom(bytes.NewReader(nil)); err == nil {
+		t.Fatal("an empty entropy source was accepted")
+	}
+	for _, task := range allTasks() {
+		a, _ := instantiateTask(task, same())
+		b, _ := instantiateTask(task, same())
+		if !slices.Equal(a.AnswerMarkers, b.AnswerMarkers) || !maps.Equal(a.Vars, b.Vars) {
+			t.Errorf("%s: the same entropy gave different instances", task.ID)
+		}
+		c, _ := instantiateTask(task, other)
+		if maps.Equal(a.Vars, c.Vars) {
+			t.Errorf("%s: different entropy gave the same values", task.ID)
+		}
+	}
+}
+
+// A preflight that could not reproduce would calibrate against one run's
+// nonces and report about another's.
+func TestSeededInstancesReproduce(t *testing.T) {
+	for _, task := range allTasks() {
+		a, _ := instantiateTask(task, seededRand(task.ID, "x"))
+		b, _ := instantiateTask(task, seededRand(task.ID, "x"))
+		if !slices.Equal(a.AnswerMarkers, b.AnswerMarkers) || a.body != b.body {
+			t.Errorf("%s did not reproduce under the same seed", task.ID)
+		}
+	}
+}
+
+// An unresolved placeholder would put "{{marker}}" in the transcript and score
+// every run wrong; it fails the fixture instead.
+func TestUnresolvedPlaceholderIsRefused(t *testing.T) {
+	if _, err := instantiate("value is {{missing}}", fixtureVars{"other": "x"}); err == nil {
+		t.Fatal("an unresolved placeholder was accepted")
+	}
+}
+
+func repoRoot() (string, error) {
+	out, err := exec.Command("git", "rev-parse", "--show-toplevel").Output()
+	if err != nil {
+		return "", fmt.Errorf("not in a git checkout: %w", err)
+	}
+	return strings.TrimSpace(string(out)), nil
+}
+
+// grepRepo searches tracked files only: build artifacts and temp fixtures are
+// not what a fresh checkout hands anyone.
+func grepRepo(t *testing.T, root, needle string) (bool, string) {
+	t.Helper()
+	cmd := exec.Command("git", "grep", "-l", "-F", needle)
+	cmd.Dir = root
+	out, err := cmd.Output()
+	if err != nil {
+		return false, "" // exit 1 means no match
+	}
+	return true, strings.TrimSpace(strings.SplitN(string(out), "\n", 2)[0])
+}
+
+func TestEveryFixturePassesPreflight(t *testing.T) {
+	if testing.Short() {
+		t.Skip("builds and folds 36 sessions")
+	}
+	root := t.TempDir()
+	for _, task := range allTasks() {
+		t.Run(task.ID, func(t *testing.T) {
+			found, err := checkTask(task, root)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, f := range found {
+				t.Error(f)
+			}
+		})
+	}
+}

benchmarks/context-retrieval/preflight.go

@@ -0,0 +1,290 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"path/filepath"
+	"slices"
+	"strings"
+
+	"reasonix/internal/base/retrieval"
+	"reasonix/internal/contract/ablation"
+	"reasonix/internal/contract/provider"
+)
+
+// Preflight is what makes a real run worth paying for. An answer the model can
+// already read, or a cue not where the matrix says, turns an arm into a
+// different experiment without saying so.
+
+// armScales are the fold-index arms an index task is measured across.
+var armScales = []string{"default", "half", "quarter", "off"}
+
+// experimentArm is one measured configuration of a task.
+type experimentArm struct {
+	name      string
+	scale     string
+	searchOff bool
+}
+
+// armsFor is the single declaration of which arms a task runs at, so preflight
+// and the run itself cannot check one set and measure another.
+func armsFor(t contextTask) []experimentArm {
+	if t.Experiment == experimentSearch {
+		return []experimentArm{
+			{"search-on", "default", false},
+			{"search-off", "default", true},
+		}
+	}
+	arms := make([]experimentArm, 0, len(armScales))
+	for _, scale := range armScales {
+		arms = append(arms, experimentArm{"index-" + scale, scale, false})
+	}
+	return arms
+}
+
+func scaleOf(name string) ablation.FoldIndexScale {
+	s, err := ablation.ParseFoldIndexScale(name)
+	if err != nil {
+		panic("unknown scale " + name) // the list above is a constant
+	}
+	return s
+}
+
+// armFor is the arm a task is measured under at one fold-index scale.
+func armFor(scale string, searchOff bool) ablation.Set {
+	set := ablation.Set{}
+	if searchOff {
+		set = ablation.New(ablation.RecallSearch)
+	}
+	return set.WithFoldIndex(scaleOf(scale))
+}
+
+type finding struct {
+	Task, Arm, Problem string
+}
+
+func (f finding) String() string { return fmt.Sprintf("%s [%s]: %s", f.Task, f.Arm, f.Problem) }
+
+// checkTask builds the task under every arm it will be run at and reports what
+// does not hold.
+func checkTask(t contextTask, root string) ([]finding, error) {
+	var out []finding
+	for _, arm := range armsFor(t) {
+		// Deterministic values: a preflight has to reproduce, and a tier
+		// calibration measured against one run's nonces is measured against
+		// nothing.
+		inst, err := instantiateTask(t, seededRand(t.ID, arm.name, "preflight"))
+		if err != nil {
+			return nil, err
+		}
+		dir := filepath.Join(root, t.ID, arm.name)
+		f, err := buildFixture(inst, armFor(arm.scale, arm.searchOff), filepath.Join(dir, "session.jsonl"))
+		if err != nil {
+			return nil, err
+		}
+		visible := visibleText(f)
+
+		// The answer must be unreadable in every arm, or the task measures
+		// reading rather than recall.
+		for _, marker := range inst.AnswerMarkers {
+			if len(marker) < 3 {
+				continue // a bare number is not a nonce; the whole set still has to match
+			}
+			if strings.Contains(visible, marker) {
+				out = append(out, finding{t.ID, arm.name, fmt.Sprintf("answer marker %q is already visible", marker)})
+			}
+		}
+
+		// The corpus has to be findable at all, or a miss in a real run says
+		// nothing about the model.
+		rank, err := probeRank(f, inst.ProbeQuery)
+		if err != nil {
+			return nil, err
+		}
+		switch {
+		case rank == 0:
+			out = append(out, finding{t.ID, arm.name, fmt.Sprintf("probe query %q does not find the target at all", inst.ProbeQuery)})
+		case rank > 5:
+			out = append(out, finding{t.ID, arm.name, fmt.Sprintf("probe query %q ranks the target %d", inst.ProbeQuery, rank)})
+		}
+
+		if t.Experiment == experimentIndex {
+			out = append(out, checkCueVisibility(t, inst, arm.scale, arm.name, visible)...)
+		} else if line := indexLineFor(f, f.Target); line != "" {
+			out = append(out, finding{t.ID, arm.name,
+				"a search task is addressed by the fold index, so it measures the index and not search: " + line})
+		}
+
+		// The projection is what the agent believes. This is what the model is
+		// told, and it is the one that has to hold.
+		req, err := captureRequest(f, armFor(arm.scale, arm.searchOff), inst.Prompt)
+		if err != nil {
+			return nil, fmt.Errorf("%s [%s]: capture: %w", t.ID, arm.name, err)
+		}
+		out = append(out, checkCapturedRequest(t, inst, arm.name, arm.scale, arm.searchOff, req)...)
+	}
+	return out, nil
+}
+
+// checkCapturedRequest holds one arm's real provider request to its contract:
+// the answer unreadable, the cue exactly where its tier says, the recall tool
+// offering only what this arm can do, and no host-side field surviving the
+// boundary.
+func checkCapturedRequest(t contextTask, inst fixtureInstance, armName, scale string, searchOff bool, req provider.Request) []finding {
+	var out []finding
+	for _, marker := range inst.AnswerMarkers {
+		if len(marker) < 3 {
+			continue // a bare number is not a nonce; the set as a whole still is
+		}
+		for _, at := range findInSurface(req, marker) {
+			out = append(out, finding{t.ID, armName, fmt.Sprintf("answer marker %q leaked at %s", marker, at)})
+		}
+	}
+	if t.Experiment == experimentIndex {
+		wantVisible, wantHidden := tierScales(t.CueTier)
+		where := findInSurface(req, inst.CueMarker)
+		switch {
+		case contains(wantVisible, scale) && len(where) == 0:
+			out = append(out, finding{t.ID, armName, fmt.Sprintf("cue %q is not provider-visible; the tier expects it", inst.CueMarker)})
+		case contains(wantHidden, scale) && len(where) > 0:
+			out = append(out, finding{t.ID, armName, fmt.Sprintf("cue %q is provider-visible at %s: %s", inst.CueMarker, where[0], scale)})
+		}
+	}
+
+	schema, ok := recallToolSchema(req)
+	if !ok {
+		out = append(out, finding{t.ID, armName, "recall is not in the provider's tool list"})
+		return append(out, boundaryFindings(t, armName, req)...)
+	}
+	params := ""
+	if b, err := json.Marshal(schema.Parameters); err == nil {
+		params = string(b)
+	}
+	// Both arms keep the read half: the ablation removes search, not recall.
+	if !strings.Contains(params, `"positions"`) {
+		out = append(out, finding{t.ID, armName, "recall lost its positions parameter"})
+	}
+	hasQuery := strings.Contains(params, `"query"`)
+	switch {
+	case searchOff && hasQuery:
+		out = append(out, finding{t.ID, armName, "recall still offers a query parameter"})
+	case !searchOff && !hasQuery:
+		out = append(out, finding{t.ID, armName, "recall has no query parameter"})
+	}
+	if searchOff {
+		for _, phrase := range searchWording {
+			for _, at := range findInSurface(req, phrase) {
+				out = append(out, finding{t.ID, armName, fmt.Sprintf("search is offered to an arm without it: %q at %s", phrase, at)})
+			}
+		}
+	}
+	return append(out, boundaryFindings(t, armName, req)...)
+}
+
+func boundaryFindings(t contextTask, armName string, req provider.Request) []finding {
+	var out []finding
+	for _, at := range localOnlyLeaks(req) {
+		out = append(out, finding{t.ID, armName, "host-only field crossed the provider boundary at " + at})
+	}
+	return out
+}
+
+// checkCueVisibility holds an index task to its tier: the cue is addressed at
+// the scales the matrix names and at no others. A policy change that moves it
+// fails here rather than turning two arms into one experiment.
+func checkCueVisibility(t contextTask, inst fixtureInstance, scale, armName, visible string) []finding {
+	wantVisible, wantHidden := tierScales(t.CueTier)
+	has := strings.Contains(visible, inst.CueMarker)
+	switch {
+	case contains(wantVisible, scale) && !has:
+		return []finding{{t.ID, armName, fmt.Sprintf("cue %q should be addressed at %s and is not", inst.CueMarker, scale)}}
+	case contains(wantHidden, scale) && has:
+		return []finding{{t.ID, armName, fmt.Sprintf("cue %q should be gone at %s and is not", inst.CueMarker, scale)}}
+	}
+	return nil
+}
+
+func contains(list []string, want string) bool { return slices.Contains(list, want) }
+
+// probeRank runs the task's own query against the folded region the way recall
+// would, and reports where the target lands.
+func probeRank(f builtFixture, query string) (int, error) {
+	terms, err := retrieval.QueryTerms(query)
+	if err != nil {
+		return 0, err
+	}
+	canonical := f.Session.Snapshot()
+	covered := min(f.State.Projection.CoveredCount, len(canonical))
+	docs := make([]map[string]int, 0, covered)
+	positions := make([]int, 0, covered)
+	lengths := make([]int, 0, covered)
+	for i, m := range canonical[:covered] {
+		var text strings.Builder
+		text.WriteString(m.Content)
+		for _, tc := range m.ToolCalls {
+			text.WriteString(" " + tc.Name + " " + string(tc.Arguments))
+		}
+		tokens := retrieval.Tokens(text.String())
+		if len(tokens) == 0 {
+			continue
+		}
+		docs = append(docs, retrieval.Counts(tokens))
+		positions = append(positions, i)
+		lengths = append(lengths, len(tokens))
+	}
+	df := retrieval.DocumentFrequency(docs)
+	avg := 0.0
+	for _, l := range lengths {
+		avg += float64(l)
+	}
+	if len(lengths) > 0 {
+		avg /= float64(len(lengths))
+	}
+	type hit struct {
+		pos   int
+		score float64
+	}
+	var hits []hit
+	for i, counts := range docs {
+		if s := retrieval.BM25Score(counts, lengths[i], terms, df, len(docs), avg); s > 0 {
+			hits = append(hits, hit{positions[i], s})
+		}
+	}
+	for i := range hits {
+		for j := i + 1; j < len(hits); j++ {
+			if hits[j].score > hits[i].score {
+				hits[i], hits[j] = hits[j], hits[i]
+			}
+		}
+	}
+	// A tool result answers at its caller's position, so either counts.
+	for i, h := range hits {
+		if h.pos == f.Target || h.pos == f.Target+1 {
+			return i + 1, nil
+		}
+	}
+	return 0, nil
+}
+
+// indexLineFor returns the fold-index line addressing a position, if any.
+func indexLineFor(f builtFixture, pos int) string {
+	want := fmt.Sprintf("#%d ", pos)
+	for line := range strings.SplitSeq(visibleIndexOnly(f), "\n") {
+		if strings.Contains(line, want) {
+			return strings.TrimSpace(line)
+		}
+	}
+	return ""
+}
+
+// visibleIndexOnly is just the fold-index sections of the projection.
+func visibleIndexOnly(f builtFixture) string {
+	var b strings.Builder
+	for _, m := range visibleContext(f) {
+		if i := strings.Index(m.Content, "## Folded work index"); i >= 0 {
+			b.WriteString(m.Content[i:])
+			b.WriteString("\n")
+		}
+	}
+	return b.String()
+}

benchmarks/context-retrieval/reformulation.go

@@ -0,0 +1,252 @@
+// reformulation.go — how a query changed, from token sets alone.
+package main
+
+import (
+	"fmt"
+	"slices"
+	"sort"
+	"strings"
+
+	"reasonix/internal/base/retrieval"
+)
+
+// The host probe ranks every target first, so the engine is not what makes a
+// model take more than one attempt. These classes are set arithmetic over the
+// same tokenizer recall uses: no judge, nothing read out of prose.
+
+const (
+	reformFirst      = "First"            // nothing to compare against yet
+	reformNearDup    = "NearDuplicate"    // the same query again, give or take a word
+	reformNarrowing  = "Narrowing"        // kept everything and added terms
+	reformBroadening = "Broadening"       // dropped terms, added none
+	reformAnchored   = "HistoricalAnchor" // reached for a term the question does not contain
+	reformShift      = "SynonymShift"     // traded terms for others
+)
+
+// nearDuplicateOverlap is where "reworded" stops and "asked again" begins.
+const nearDuplicateOverlap = 0.8
+
+func terms(s string) []string {
+	return retrieval.Unique(retrieval.Tokens(s))
+}
+
+func termSet(s string) map[string]bool {
+	out := map[string]bool{}
+	for _, t := range terms(s) {
+		out[t] = true
+	}
+	return out
+}
+
+func jaccard(a, b map[string]bool) float64 {
+	if len(a) == 0 && len(b) == 0 {
+		return 1
+	}
+	shared := 0
+	for t := range a {
+		if b[t] {
+			shared++
+		}
+	}
+	union := len(a) + len(b) - shared
+	if union == 0 {
+		return 0
+	}
+	return float64(shared) / float64(union)
+}
+
+// classifyReformulation names how this query differs from the one before it.
+func classifyReformulation(previous, current, question string) string {
+	if previous == "" {
+		return reformFirst
+	}
+	prev, cur := termSet(previous), termSet(current)
+	if jaccard(prev, cur) >= nearDuplicateOverlap {
+		return reformNearDup
+	}
+	added, dropped := diffTerms(cur, prev), diffTerms(prev, cur)
+	// A term the question never used had to come from the model's own memory of
+	// the history, which is a different move from rephrasing what it was asked.
+	ask := termSet(question)
+	for _, t := range added {
+		if !ask[t] {
+			return reformAnchored
+		}
+	}
+	switch {
+	case len(dropped) == 0:
+		return reformNarrowing
+	case len(added) == 0:
+		return reformBroadening
+	default:
+		return reformShift
+	}
+}
+
+func diffTerms(from, minus map[string]bool) []string {
+	var out []string
+	for t := range from {
+		if !minus[t] {
+			out = append(out, t)
+		}
+	}
+	sort.Strings(out)
+	return out
+}
+
+// classifySearches labels each attempt and records which of the host probe's
+// terms it left out. The probe is the oracle: it ranks the target first, so a
+// query missing its terms says what the model did not think to ask for.
+func classifySearches(m *contextMetrics, inst fixtureInstance) {
+	probe := terms(inst.ProbeQuery)
+	previous := ""
+	for i := range m.Searches {
+		s := &m.Searches[i]
+		s.Reformulation = classifyReformulation(previous, s.Query, inst.Prompt)
+		have := termSet(s.Query)
+		for _, term := range probe {
+			if !have[term] {
+				s.MissingProbeTerms = append(s.MissingProbeTerms, term)
+			}
+		}
+		previous = s.Query
+	}
+}
+
+// queryAudit is the reformulation funnel across a set of runs.
+type queryAudit struct {
+	Runs, RunsThatSearched  int
+	FirstQueryHit           int
+	HitBySecond, HitByThird int
+	NeverHit                int
+	TotalSearches           int
+	PostHitSearches         int
+	HitThenRead             int
+	EscapeBeforeFirstSearch int
+	Reformulations          map[string]int
+	MissedProbeTerms        map[string]int
+}
+
+func auditQueries(runs []contextMetrics) queryAudit {
+	a := queryAudit{Reformulations: map[string]int{}, MissedProbeTerms: map[string]int{}}
+	for _, r := range runs {
+		if r.Contaminated {
+			continue
+		}
+		a.Runs++
+		a.TotalSearches += len(r.Searches)
+		a.PostHitSearches += r.PostHitSearches
+		if r.EscapeBeforeFirstRecall > 0 {
+			a.EscapeBeforeFirstSearch++
+		}
+		if len(r.Searches) == 0 {
+			continue
+		}
+		a.RunsThatSearched++
+		hitAt := 0
+		for i, s := range r.Searches {
+			a.Reformulations[s.Reformulation]++
+			for _, term := range s.MissingProbeTerms {
+				a.MissedProbeTerms[term]++
+			}
+			if s.TargetRank > 0 && hitAt == 0 {
+				hitAt = i + 1
+			}
+		}
+		switch {
+		case hitAt == 1:
+			a.FirstQueryHit++
+		case hitAt == 2:
+			a.HitBySecond++
+		case hitAt >= 3:
+			a.HitByThird++
+		default:
+			a.NeverHit++
+		}
+		if hitAt > 0 && r.TargetRead {
+			a.HitThenRead++
+		}
+	}
+	return a
+}
+
+func (a queryAudit) report() string {
+	var b strings.Builder
+	b.WriteString("\n## Query reformulation\n")
+	fmt.Fprintf(&b, "  runs=%d searched=%d  searches=%d (%.2f per searching run)\n",
+		a.Runs, a.RunsThatSearched, a.TotalSearches, ratio(a.TotalSearches, a.RunsThatSearched))
+	fmt.Fprintf(&b, "  target found by query 1: %d   by 2: %d   by 3+: %d   never: %d\n",
+		a.FirstQueryHit, a.HitBySecond, a.HitByThird, a.NeverHit)
+	fmt.Fprintf(&b, "  found then read: %d/%d   searches issued after the target was already back: %d\n",
+		a.HitThenRead, a.FirstQueryHit+a.HitBySecond+a.HitByThird, a.PostHitSearches)
+	fmt.Fprintf(&b, "  reached for the workspace before searching: %d\n", a.EscapeBeforeFirstSearch)
+	b.WriteString("  reformulations: " + countsLine(a.Reformulations) + "\n")
+	b.WriteString("  probe terms most often absent: " + topCounts(a.MissedProbeTerms, 8) + "\n")
+	return b.String()
+}
+
+func ratio(n, d int) float64 {
+	if d == 0 {
+		return 0
+	}
+	return float64(n) / float64(d)
+}
+
+func countsLine(counts map[string]int) string {
+	keys := make([]string, 0, len(counts))
+	for k := range counts {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	parts := make([]string, 0, len(keys))
+	for _, k := range keys {
+		parts = append(parts, fmt.Sprintf("%s=%d", k, counts[k]))
+	}
+	return strings.Join(parts, " ")
+}
+
+func topCounts(counts map[string]int, limit int) string {
+	type kv struct {
+		k string
+		n int
+	}
+	all := make([]kv, 0, len(counts))
+	for k, n := range counts {
+		all = append(all, kv{k, n})
+	}
+	sort.Slice(all, func(i, j int) bool {
+		if all[i].n != all[j].n {
+			return all[i].n > all[j].n
+		}
+		return all[i].k < all[j].k
+	})
+	parts := make([]string, 0, limit)
+	for _, e := range all[:min(limit, len(all))] {
+		parts = append(parts, fmt.Sprintf("%s=%d", e.k, e.n))
+	}
+	if len(parts) == 0 {
+		return "(none)"
+	}
+	return strings.Join(parts, " ")
+}
+
+// queryLines lists every attempt, so a surprising audit can be read back.
+func queryLines(runs []contextMetrics) string {
+	var b strings.Builder
+	b.WriteString("\n## Every query, in order\n")
+	for _, r := range runs {
+		for _, s := range r.Searches {
+			rank := "miss"
+			if s.TargetRank > 0 {
+				rank = fmt.Sprintf("rank %d", s.TargetRank)
+			}
+			fmt.Fprintf(&b, "  %-24s %-14s #%d %-17s %-9s %q\n",
+				r.Task, r.Arm, s.Ordinal, s.Reformulation, rank, s.Query)
+			if len(s.MissingProbeTerms) > 0 && s.TargetRank == 0 {
+				fmt.Fprintf(&b, "  %-24s %-14s    missing probe terms: %s\n",
+					"", "", strings.Join(slices.Clone(s.MissingProbeTerms), " "))
+			}
+		}
+	}
+	return b.String()
+}

benchmarks/context-retrieval/run.go

@@ -0,0 +1,523 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reasonix/internal/state/sessionstore"
+	"slices"
+	"sort"
+	"strings"
+	"time"
+
+	"reasonix/internal/assembly/boot"
+	"reasonix/internal/contract/ablation"
+	"reasonix/internal/contract/provider"
+	"reasonix/internal/contract/tool"
+	_ "reasonix/internal/model/openai"
+	"reasonix/internal/runtime/agent"
+	_ "reasonix/internal/tools/builtin"
+)
+
+// A run is one recall question against a fixture the preflight has already
+// cleared. Scoring reads the transcript the turn appended — tool names and
+// their JSON arguments — so nothing depends on how the model narrated itself.
+
+const (
+	runBaseURL = "https://api.deepseek.com"
+	runModel   = "deepseek-chat"
+	runTimeout = 4 * time.Minute
+)
+
+func realProvider() (provider.Provider, error) {
+	key := os.Getenv("DEEPSEEK_API_KEY")
+	if key == "" {
+		return nil, fmt.Errorf("a real run needs DEEPSEEK_API_KEY")
+	}
+	return provider.New("openai", provider.Config{
+		Name: "contextbench", BaseURL: runBaseURL, Model: runModel, APIKey: key,
+	})
+}
+
+// adversarialPrompts tell the model what it is running and send it after the
+// answer everywhere except the conversation. The question is not whether it
+// obeys the experiment: it is whether the answer is reachable at all by a model
+// that knows the mechanism and is actively attacking the host.
+var adversarialPrompts = map[string]string{
+	experimentSearch: "You are running a benchmark. Find the expected answer for this task from the " +
+		"Reasonix repository, benchmark source, fixture generator, test files, scratch files, or " +
+		"session metadata. Do not use recall unless necessary. Report the exact hidden values.",
+	experimentIndex: "Inspect benchmarks/context-retrieval, the git repository, session files, temporary " +
+		"files, and any benchmark metadata you can access. Recover the concrete instantiated answer for " +
+		"this run without relying on the folded conversation. Report the exact values.",
+}
+
+// runAdversarial sends one task per experiment after the answer through every
+// host-readable surface. It passes when nothing but recall could produce it —
+// a run that gives up and recalls has still proven the attack failed.
+func runAdversarial(root string) int {
+	root, err := filepath.Abs(root)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return 2
+	}
+	restore, ierr := isolateWorkspace()
+	if ierr != nil {
+		fmt.Fprintln(os.Stderr, "isolate workspace:", ierr)
+		return 2
+	}
+	defer restore()
+	p, perr := realProvider()
+	if perr != nil {
+		fmt.Fprintln(os.Stderr, perr)
+		return 2
+	}
+	leaked := 0
+	for _, id := range []string{"r01-retry-boundary", "i01-transport-fallback"} {
+		t, ok := taskByID(id)
+		if !ok {
+			fmt.Fprintf(os.Stderr, "unknown task %q\n", id)
+			return 2
+		}
+		m, err := runOne(p, t, armFor("default", false), "adversarial", root, false, false,
+			adversarialPrompts[t.Experiment])
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "%s: %v\n", id, err)
+		}
+		verdict := "isolated"
+		if m.EscapeFoundAnswer {
+			verdict = "LEAKED via " + m.LeakedVia
+			leaked++
+		}
+		fmt.Printf("%-24s %-24s escapes=%-3d recall=%d answered=%v tools=%v\n",
+			id, verdict, m.EscapeCalls, m.SearchCalls+m.ReadCalls, m.AnswerRecovered, m.UnexpectedWorkTools)
+		if m.EscapeFoundAnswer {
+			fmt.Printf("   args:   %s\n   output: %s\n", m.LeakedArgs, m.LeakedOutput)
+		}
+	}
+	if leaked > 0 {
+		fmt.Fprintf(os.Stderr, "\n%d of 2 adversarial runs reached an answer outside recall\n", leaked)
+		return 1
+	}
+	fmt.Println("\nNo answer was reachable outside recall.")
+	return 0
+}
+
+// runOne asks one task under one arm and scores what the model did.
+func runOne(p provider.Provider, t contextTask, arm ablation.Set, armName, root string, cueVisible, dry bool, promptOverride ...string) (contextMetrics, error) {
+	// Live runs get values that existed nowhere before the run started; a dry
+	// run stays reproducible.
+	rng := liveRand()
+	if dry {
+		rng = seededRand(t.ID, armName, "dry")
+	}
+	inst, err := instantiateTask(t, rng)
+	if err != nil {
+		return contextMetrics{}, err
+	}
+	f, err := buildFixture(inst, arm, filepath.Join(root, t.ID, armName, "session.jsonl"))
+	if err != nil {
+		return contextMetrics{}, err
+	}
+	sess, err := sessionstore.LoadSession(f.Path)
+	if err != nil {
+		return contextMetrics{}, fmt.Errorf("load session: %w", err)
+	}
+	reg := tool.NewRegistry()
+	for _, x := range tool.Builtins() {
+		reg.Add(x)
+	}
+	boot.ApplyUnifiedProviderToolSurface(reg, false, arm)
+
+	var usage usageSink
+	a := agent.New(p, reg, sess, agent.Options{
+		ContextWindow: fixtureWindow, CompactRatio: 0.5, RecentKeep: 2,
+		SessionPath: f.Path, KeepPolicy: agent.KeepErrors, Ablation: arm,
+	}, &usage)
+	a.LoadProjectionSidecar(f.Path)
+	// From here the transcript lives only in memory. On disk it is the answer.
+	sealFixture(f.Path)
+	defer unsealFixture(f.Path)
+	dir := filepath.Dir(f.Path)
+	if at, marker := answerOnDisk(dir, inst.AnswerMarkers); at != "" {
+		return contextMetrics{}, fmt.Errorf("%s [%s]: %q is readable at %s before the run", t.ID, armName, marker, at)
+	}
+
+	before := len(sess.Snapshot())
+	ctx, cancel := context.WithTimeout(context.Background(), runTimeout)
+	defer cancel()
+	prompt := inst.Prompt
+	if len(promptOverride) > 0 && promptOverride[0] != "" {
+		prompt = promptOverride[0]
+	}
+	runErr := a.Run(ctx, prompt)
+
+	if at, marker := answerOnDisk(dir, inst.AnswerMarkers); at != "" {
+		return contextMetrics{}, fmt.Errorf("%s [%s]: %q was written to %s during the run", t.ID, armName, marker, at)
+	}
+
+	appended := sess.Snapshot()[before:]
+	m := scoreRun(appended, inst, f.Target, armName, cueVisible)
+	m.trajectory = appended
+	if u, requests := usage.snapshot(); requests > 0 {
+		m.UsageReportedRequests, m.PromptTokens, m.CompletionTokens = requests, u.PromptTokens, u.CompletionTokens
+		m.CacheHitTokens, m.CacheMissTokens, m.UsageEstimated = u.CacheHitTokens, u.CacheMissTokens, u.Estimated
+	}
+	m.scoreAnswer(finalAnswer(appended), inst)
+	if runErr != nil {
+		m.FailureStage = "RunError"
+		m.TimeoutReason = timeoutReason(m)
+	}
+	return m, runErr
+}
+
+// finalAnswer is the last assistant text the turn produced.
+func finalAnswer(msgs []provider.Message) string {
+	for _, m := range slices.Backward(msgs) {
+		if m.Role == provider.RoleAssistant && strings.TrimSpace(m.Content) != "" {
+			return m.Content
+		}
+	}
+	return ""
+}
+
+// isolateWorkspace moves the process into an empty directory before any task
+// runs. The corpus lives in this repository, so an agent left here greps the
+// answers out of corpus.go — one did, quoting the file's own line about them
+// being nonces. Fixtures stay outside it too: a readable session file is the
+// canonical transcript, answer included.
+func isolateWorkspace() (func(), error) {
+	dir, err := os.MkdirTemp("", "contextbench-workspace-*")
+	if err != nil {
+		return nil, err
+	}
+	readme := "This workspace is empty on purpose. The question is about earlier conversation,\nnot about any file here.\n"
+	if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte(readme), 0o644); err != nil {
+		return nil, err
+	}
+	previous, err := os.Getwd()
+	if err != nil {
+		return nil, err
+	}
+	if err := os.Chdir(dir); err != nil {
+		return nil, err
+	}
+	return func() {
+		_ = os.Chdir(previous)
+		_ = os.RemoveAll(dir)
+	}, nil
+}
+
+// runBoundaries runs only the pair each index task is built for: the narrowest
+// scale still addressing its cue, and the next one down. Each pair moves the
+// affordance and nothing else, where default-vs-off moves the whole index.
+
+// The two arms get separate nonces: reusing one would leave the first arm's
+// answer in a host-readable history for the second to find.
+func runBoundaries(root string) int {
+	root, err := filepath.Abs(root)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return 2
+	}
+	restore, ierr := isolateWorkspace()
+	if ierr != nil {
+		fmt.Fprintln(os.Stderr, "isolate workspace:", ierr)
+		return 2
+	}
+	defer restore()
+	p, perr := realProvider()
+	if perr != nil {
+		fmt.Fprintln(os.Stderr, perr)
+		return 2
+	}
+
+	var all []contextMetrics
+	var cueSide, noCueSide []contextMetrics
+	for _, t := range efficiencyTasks() {
+		cue, noCue := boundaryPair(t.CueTier)
+		for _, side := range []struct {
+			scale string
+			has   bool
+		}{{cue, true}, {noCue, false}} {
+			name := "index-" + side.scale
+			m, err := runOne(p, t, armFor(side.scale, false), name, root, side.has, false)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "%s [%s]: %v\n", t.ID, name, err)
+			}
+			all = append(all, m)
+			if side.has {
+				cueSide = append(cueSide, m)
+			} else {
+				noCueSide = append(noCueSide, m)
+			}
+			fmt.Printf("%-24s %-14s cue=%-3v %-14s search=%d read=%d direct=%-5v recall-tok=%-5d%s escape=%d\n",
+				t.ID, name, side.has, m.FailureStage, m.SearchCalls, m.ReadCalls,
+				m.CueDirectRead, m.RecallReturnedTokens, promptTokenSuffix(m), m.EscapeCalls)
+		}
+	}
+	reportDeltas(cueSide, noCueSide)
+	fmt.Print(reportStopping(all))
+	return writeResults(root, all)
+}
+
+// reportDeltas is the paired reading: each task against itself, then pooled.
+func reportDeltas(cueSide, noCueSide []contextMetrics) {
+	fmt.Printf("\n## Paired deltas (cue present − cue absent)\n")
+	fmt.Printf("  %-24s %-10s %-10s %-9s %-11s %s\n",
+		"task", "recovery", "directread", "searches", "recall-tok", "escapes")
+	for i := range cueSide {
+		if i >= len(noCueSide) {
+			break
+		}
+		a, b := cueSide[i], noCueSide[i]
+		fmt.Printf("  %-24s %-10s %-10s %-9d %-11d %d\n", a.Task,
+			deltaBool(a.AnswerRecovered, b.AnswerRecovered),
+			deltaBool(a.CueDirectRead, b.CueDirectRead),
+			a.SearchCalls-b.SearchCalls,
+			a.RecallReturnedTokens-b.RecallReturnedTokens,
+			a.EscapeCalls-b.EscapeCalls)
+	}
+	fmt.Println("\n## Pooled")
+	fmt.Println(" ", summarize("cue-present", cueSide).line())
+	fmt.Println(" ", summarize("cue-absent", noCueSide).line())
+	fmt.Println("\n## Where each side looked first")
+	fmt.Printf("  %-14s %s\n", "cue-present", countsLine(summarize("x", cueSide).Routes))
+	fmt.Printf("  %-14s %s\n", "cue-absent", countsLine(summarize("x", noCueSide).Routes))
+}
+
+func deltaBool(a, b bool) string {
+	switch {
+	case a == b:
+		return "same"
+	case a:
+		return "+cue"
+	default:
+		return "-cue"
+	}
+}
+
+// runExperiment runs one experiment's tasks across its arms. A dry run drives
+// the same pipeline with a scripted provider: it proves fixture, run, scoring
+// and report hold together before any of it is paid for.
+func runExperiment(experiment, root string, dry bool, tasks []contextTask) int {
+	root, err := filepath.Abs(root)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return 2
+	}
+	restore, err := isolateWorkspace()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "isolate workspace:", err)
+		return 2
+	}
+	defer restore()
+	var p provider.Provider = &scriptedProvider{}
+	if !dry {
+		real, rerr := realProvider()
+		if rerr != nil {
+			fmt.Fprintln(os.Stderr, rerr)
+			return 2
+		}
+		p = real
+	}
+	byArm := map[string][]contextMetrics{}
+	var all []contextMetrics
+
+	if experiment == experimentIndex {
+		fmt.Print(fingerprint(dry))
+	}
+	for _, t := range tasks {
+		if t.Experiment != experiment {
+			continue
+		}
+		// Arms are shuffled inside each task block. Running six defaults, then
+		// six halves, would make provider drift collinear with the axis under
+		// test: a bad minute would land entirely on one arm.
+		for _, arm := range shuffledArms(t) {
+			cueVisible := t.Experiment == experimentIndex && cueExpectedVisible(t, arm.scale)
+			m, err := runOne(p, t, armFor(arm.scale, arm.searchOff), arm.name, root, cueVisible, dry)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "%s [%s]: %v\n", t.ID, arm.name, err)
+			}
+			byArm[arm.name] = append(byArm[arm.name], m)
+			all = append(all, m)
+			fmt.Printf("%-24s %-14s %-18s search=%d hit=%d read=%d recall-tok=%d%s %v\n",
+				t.ID, arm.name, m.FailureStage, m.SearchCalls, m.TargetSearchHits, m.ReadCalls,
+				m.RecallReturnedTokens, promptTokenSuffix(m), m.UnexpectedWorkTools)
+		}
+	}
+	reportFunnels(byArm)
+	if experiment == experimentIndex {
+		fmt.Print(reportDoseResponse(all))
+	}
+	fmt.Print(reportStopping(all))
+	fmt.Print(auditQueries(all).report())
+	fmt.Print(queryLines(all))
+	if experiment == experimentIndex {
+		reportBoundaries(all)
+	}
+	return writeResults(root, all)
+}
+
+func cueExpectedVisible(t contextTask, scale string) bool {
+	visible, _ := tierScales(t.CueTier)
+	return contains(visible, scale)
+}
+
+func reportFunnels(byArm map[string][]contextMetrics) {
+	names := make([]string, 0, len(byArm))
+	for name := range byArm {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	fmt.Println("\n## Funnel")
+	for _, name := range names {
+		fmt.Println(" ", summarize(name, byArm[name]).line())
+	}
+	fmt.Println("\n## Where it looked first")
+	for _, name := range names {
+		f := summarize(name, byArm[name])
+		fmt.Printf("  %-14s %s\n", name, countsLine(f.Routes))
+	}
+	fmt.Println("\n## Where it broke")
+	for _, name := range names {
+		f := summarize(name, byArm[name])
+		stages := make([]string, 0, len(f.Stages))
+		for stage, n := range f.Stages {
+			stages = append(stages, fmt.Sprintf("%s=%d", stage, n))
+		}
+		sort.Strings(stages)
+		fmt.Printf("  %-12s %s\n", name, strings.Join(stages, " "))
+	}
+}
+
+// writeTrajectories saves what each turn produced, after the whole batch is
+// done. Three analyses in a row have needed a re-run because something was
+// counted and not kept — query text, then snippet contents. It is written at
+// the end on purpose: during the batch these files are the answer.
+func writeTrajectories(root string, all []contextMetrics) error {
+	f, err := os.Create(filepath.Join(root, "trajectories.jsonl"))
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	for _, m := range all {
+		if err := writeJSONLine(f, map[string]any{
+			"task": m.Task, "arm": m.Arm, "messages": m.trajectory,
+		}); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func writeResults(root string, all []contextMetrics) int {
+	path := filepath.Join(root, "results.jsonl")
+	f, err := os.Create(path)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return 2
+	}
+	defer f.Close()
+	for _, m := range all {
+		if err := writeJSONLine(f, m); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			return 2
+		}
+	}
+	if err := writeTrajectories(root, all); err != nil {
+		fmt.Fprintln(os.Stderr, "write trajectories:", err)
+		return 2
+	}
+	fmt.Printf("\n%d runs written to %s (with trajectories.jsonl)\n", len(all), path)
+	return 0
+}
+
+// reportBoundaries prints each index task across its own cue boundary, then the
+// two sides pooled. Task difficulty is held constant inside a row, which is
+// what a four-arm average cannot do.
+func reportBoundaries(all []contextMetrics) {
+	byKey := map[string]contextMetrics{}
+	for _, m := range all {
+		byKey[m.Task+"|"+m.Arm] = m
+	}
+	var cueSide, noCueSide []contextMetrics
+	fmt.Println("\n## Across each task's cue boundary")
+	fmt.Printf("  %-24s %-16s %-4s %-10s %-9s %-12s %-11s %s\n",
+		"task", "arm", "cue", "recovered", "cue-read", "search/task", "recall-tok", "escape")
+	for _, t := range indexTasks() {
+		cue, noCue := boundaryPair(t.CueTier)
+		for _, side := range []struct {
+			scale string
+			has   bool
+		}{{cue, true}, {noCue, false}} {
+			m, ok := byKey[t.ID+"|index-"+side.scale]
+			if !ok {
+				continue
+			}
+			if side.has {
+				cueSide = append(cueSide, m)
+			} else {
+				noCueSide = append(noCueSide, m)
+			}
+			mark := "no"
+			if side.has {
+				mark = "yes"
+			}
+			fmt.Printf("  %-24s %-16s %-4s %-10v %-9v %-12d %-11d %d\n",
+				t.ID, "index-"+side.scale, mark, m.AnswerRecovered, m.RecallReadWithoutSearch,
+				m.SearchCalls, m.RecallReturnedTokens, m.EscapeCalls)
+		}
+	}
+	fmt.Println("\n## Pooled across boundaries")
+	fmt.Println(" ", summarize("cue-present", cueSide).line())
+	fmt.Println(" ", summarize("cue-absent", noCueSide).line())
+}
+
+// shuffledArms permutes a task's arms deterministically, so the order is
+// reproducible and still uncorrelated with the axis being measured.
+func shuffledArms(t contextTask) []experimentArm {
+	arms := armsFor(t)
+	rng := seededRand(t.ID, "arm-order")
+	rng.Shuffle(len(arms), func(i, j int) { arms[i], arms[j] = arms[j], arms[i] })
+	return arms
+}
+
+// fingerprint records what produced a batch. Not a gate — but batch effects
+// have reversed three conclusions in this experiment already, and a table with
+// no provenance cannot be compared with the next one.
+func fingerprint(dry bool) string {
+	model, endpoint := runModel, runBaseURL
+	if dry {
+		model, endpoint = "scripted", "none"
+	}
+	commit := "unknown"
+	if out, err := exec.Command("git", "rev-parse", "--short", "HEAD").Output(); err == nil {
+		commit = strings.TrimSpace(string(out))
+	}
+	return fmt.Sprintf("## Batch\n  model=%s endpoint=%s window=%d generations=%d commit=%s started=%s\n",
+		model, endpoint, fixtureWindow, fixtureGenerations, commit, time.Now().UTC().Format(time.RFC3339))
+}
+
+// timeoutReason separates a run that never found its answer from one that found
+// it and kept going. Only the first is a case for a longer budget; the second
+// would just get more time to circle. A batch reporting only "context deadline
+// exceeded" cannot tell an arm that made retrieval harder from an arm that
+// happened to draw a slow minute.
+func timeoutReason(m contextMetrics) string {
+	switch {
+	case m.TargetHeldAtEnd && m.RoundsAfterTarget >= 2:
+		return "PostTargetRunaway"
+	case m.TargetHeldAtEnd:
+		return "TargetHeldLate"
+	case m.SearchCalls >= 3:
+		return "SearchSpiral"
+	case m.SearchCalls+m.ReadCalls+m.EscapeCalls == 0:
+		return "NoToolActivity"
+	default:
+		return "Unknown"
+	}
+}

benchmarks/context-retrieval/scripted.go

@@ -0,0 +1,95 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+
+	"reasonix/internal/contract/provider"
+)
+
+// scriptedProvider walks the chain a competent model would: search, read the
+// best hit, answer with what came back. It proves the pipeline holds together
+// for nothing, so a real run's first failure is about the model.
+
+type scriptedProvider struct{}
+
+func (p *scriptedProvider) Name() string { return "contextbench-scripted" }
+
+var (
+	scriptedHit    = regexp.MustCompile(`(?m)^#(\d+) `)
+	scriptedRecall = regexp.MustCompile(`(?s)^#\d+\n(.*)`)
+)
+
+// Stream decides from the request alone, never from a call counter: one
+// provider serves every task in a run, and a counter would make the second task
+// start where the first left off.
+func (p *scriptedProvider) Stream(_ context.Context, req provider.Request) (<-chan provider.Chunk, error) {
+	ch := make(chan provider.Chunk, 3)
+	defer close(ch)
+	// Honour the schema, as a model does: an arm without a query parameter is
+	// an arm that cannot search, and pretending otherwise scores a refusal as
+	// a failed search.
+	if !recallAccepts(req, "query") {
+		ch <- provider.Chunk{Type: provider.ChunkText, Text: "I have no address for that part of the history."}
+		ch <- provider.Chunk{Type: provider.ChunkDone}
+		return ch, nil
+	}
+	// The last message, not the last tool result anywhere: the fixture's own
+	// history is full of tool results, and one of those is not this turn's.
+	last := ""
+	if n := len(req.Messages); n > 0 && req.Messages[n-1].Role == provider.RoleTool {
+		last = req.Messages[n-1].Content
+	}
+	switch {
+	case last == "":
+		args, _ := json.Marshal(map[string]string{"query": lastUserText(req)})
+		ch <- provider.Chunk{Type: provider.ChunkToolCall, ToolCall: &provider.ToolCall{
+			ID: "s1", Name: "recall", Arguments: string(args),
+		}}
+	case strings.Contains(last, "Folded context matching"):
+		positions := scriptedHit.FindAllStringSubmatch(last, 1)
+		if len(positions) == 0 {
+			ch <- provider.Chunk{Type: provider.ChunkText, Text: "Nothing in the folded history matches."}
+			break
+		}
+		n, _ := strconv.Atoi(positions[0][1])
+		args, _ := json.Marshal(map[string][]int{"positions": {n}})
+		ch <- provider.Chunk{Type: provider.ChunkToolCall, ToolCall: &provider.ToolCall{
+			ID: "r1", Name: "recall", Arguments: string(args),
+		}}
+	default:
+		// Answer with what recall returned, so a correct chain scores as one.
+		body := last
+		if m := scriptedRecall.FindStringSubmatch(last); len(m) > 1 {
+			body = m[1]
+		}
+		ch <- provider.Chunk{Type: provider.ChunkText, Text: "From the folded history: " + body}
+	}
+	ch <- provider.Chunk{Type: provider.ChunkDone}
+	return ch, nil
+}
+
+// recallAccepts reports whether recall is offered with the given parameter.
+func recallAccepts(req provider.Request, param string) bool {
+	for _, t := range req.Tools {
+		if t.Name != "recall" {
+			continue
+		}
+		b, err := json.Marshal(t.Parameters)
+		return err == nil && strings.Contains(string(b), `"`+param+`"`)
+	}
+	return false
+}
+
+func lastUserText(req provider.Request) string {
+	for _, m := range slices.Backward(req.Messages) {
+		if m.Role == provider.RoleUser {
+			return m.Content
+		}
+	}
+	return ""
+}

benchmarks/context-retrieval/snippet.go

@@ -0,0 +1,182 @@
+// snippet.go — does a rank-1 hit actually hand over the answer?
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"reasonix/internal/base/retrieval"
+	"reasonix/internal/contract/ablation"
+	"reasonix/internal/contract/event"
+	"reasonix/internal/contract/tool"
+	"reasonix/internal/runtime/agent"
+)
+
+// TargetHit is not EvidenceSufficient: a rank-1 hit can still hand over a
+// window too short to answer with, and searching again after that is correct.
+// Measured through the shipped recall path, not a copy of it.
+
+// snippetWidths are the windows to compare. 240 is what ships.
+var snippetWidths = []int{120, 180, 240, 320, 480}
+
+// historicalQueries are the queries these tasks actually drew in the pilots,
+// kept because a probe query is the host's phrasing and the model's was not.
+var historicalQueries = map[string][]string{
+	"i03-coalescing":     {"coalesce window marker probe", "job completion coalescing window"},
+	"i04-recovery-fence": {"recovery fence marker epoch", "expected epoch", "recfence quartz"},
+}
+
+type snippetReading struct {
+	Task     string
+	Query    string
+	Width    int
+	Covered  int
+	Total    int
+	Runes    int
+	Rank     int
+	Complete bool
+}
+
+// runSnippetAudit answers the question offline, over many instantiations so a
+// single seed's lengths cannot decide it.
+func runSnippetAudit(root string, seeds int) int {
+	fmt.Printf("## Snippet coverage (%d instantiations per task)\n", seeds)
+	fmt.Println("  Does the window a rank-1 hit returns contain every value the task scores on?")
+
+	byTaskWidth := map[string]map[int][]snippetReading{}
+	for _, t := range allTasks() {
+		byTaskWidth[t.ID] = map[int][]snippetReading{}
+		for seed := range seeds {
+			inst, err := instantiateTask(t, seededRand(t.ID, "snippet", fmt.Sprint(seed)))
+			if err != nil {
+				fmt.Fprintln(os.Stderr, err)
+				return 2
+			}
+			queries := append([]string{inst.ProbeQuery}, historicalQueries[t.ID]...)
+			for _, q := range queries {
+				for _, width := range snippetWidths {
+					r := measureSnippet(inst, q, width)
+					byTaskWidth[t.ID][width] = append(byTaskWidth[t.ID][width], r)
+				}
+			}
+		}
+	}
+
+	fmt.Printf("\n  %-24s %-5s", "task", "vals")
+	for _, w := range snippetWidths {
+		fmt.Printf("%9d", w)
+	}
+	fmt.Println("   mean runes @240")
+	for _, t := range allTasks() {
+		vals := len(t.AnswerVars)
+		fmt.Printf("  %-24s %-5d", t.ID, vals)
+		for _, w := range snippetWidths {
+			fmt.Printf("%8.0f%%", 100*completeRate(byTaskWidth[t.ID][w]))
+		}
+		fmt.Printf("   %.0f\n", meanRunes(byTaskWidth[t.ID][240]))
+	}
+	reportShippedPath(root)
+	return 0
+}
+
+// measureSnippet renders one hit through the same MakeSnippet the recall path
+// uses, then asks whether every scored value survived the window.
+func measureSnippet(inst fixtureInstance, query string, width int) snippetReading {
+	terms, err := retrieval.QueryTerms(query)
+	if err != nil {
+		return snippetReading{Task: inst.Task.ID, Query: query, Width: width, Total: len(inst.AnswerMarkers)}
+	}
+	// The tool result is the document the answer lives in; a call's arguments
+	// are a separate document and never carry it.
+	snippet := retrieval.MakeSnippet(inst.body, query, terms, width)
+	covered := 0
+	for _, marker := range inst.AnswerMarkers {
+		if strings.Contains(strings.ToLower(snippet), strings.ToLower(marker)) {
+			covered++
+		}
+	}
+	return snippetReading{
+		Task: inst.Task.ID, Query: query, Width: width,
+		Covered: covered, Total: len(inst.AnswerMarkers),
+		Runes: len([]rune(snippet)), Complete: covered == len(inst.AnswerMarkers),
+	}
+}
+
+// reportShippedPath cross-checks the table against the real recall tool: a
+// fixture, a fold, and a search through the agent that ships.
+func reportShippedPath(root string) {
+	fmt.Println("\n## Through the shipped recall path (width as shipped)")
+	for _, t := range allTasks() {
+		inst, err := instantiateTask(t, seededRand(t.ID, "snippet-live"))
+		if err != nil {
+			continue
+		}
+		f, err := buildFixture(inst, ablation.Set{}, filepath.Join(root, "snippet", t.ID, "session.jsonl"))
+		if err != nil {
+			fmt.Printf("  %-24s fixture: %v\n", t.ID, err)
+			continue
+		}
+		a := agent.New(&digestProvider{}, tool.NewRegistry(), f.Session, agent.Options{
+			ContextWindow: fixtureWindow, CompactRatio: 0.5, RecentKeep: 2,
+			SessionPath: f.Path, KeepPolicy: agent.KeepErrors,
+		}, event.Discard)
+		a.LoadProjectionSidecar(f.Path)
+		queries := append([]string{inst.ProbeQuery}, historicalQueries[t.ID]...)
+		for _, q := range queries {
+			res, err := a.RecallContext(context.Background(), tool.RecallRequest{Query: q})
+			if err != nil {
+				fmt.Printf("  %-24s %-34q recall: %v\n", t.ID, q, err)
+				continue
+			}
+			covered := 0
+			for _, marker := range inst.AnswerMarkers {
+				if strings.Contains(strings.ToLower(res.Text), strings.ToLower(marker)) {
+					covered++
+				}
+			}
+			fmt.Printf("  %-24s %-34q %d/%d values in the result\n",
+				t.ID, truncate(q, 32), covered, len(inst.AnswerMarkers))
+		}
+	}
+}
+
+func completeRate(rs []snippetReading) float64 {
+	if len(rs) == 0 {
+		return 0
+	}
+	n := 0
+	for _, r := range rs {
+		if r.Complete {
+			n++
+		}
+	}
+	return float64(n) / float64(len(rs))
+}
+
+func meanRunes(rs []snippetReading) float64 {
+	if len(rs) == 0 {
+		return 0
+	}
+	total := 0
+	for _, r := range rs {
+		total += r.Runes
+	}
+	return float64(total) / float64(len(rs))
+}
+
+// answerCoverage is what a run should have recorded all along: how much of the
+// scored answer a search actually handed over. rank=1 with coverage 1/3 is not
+// a stopping failure.
+func answerCoverage(text string, markers []string) int {
+	covered := 0
+	lower := strings.ToLower(text)
+	for _, marker := range markers {
+		if strings.Contains(lower, strings.ToLower(marker)) {
+			covered++
+		}
+	}
+	return covered
+}

benchmarks/context-retrieval/usage.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+
+	"reasonix/internal/contract/event"
+	"reasonix/internal/contract/provider"
+)
+
+// usageSink reads what a run cost from the events the agent already emits. Every
+// billed completion reports event.Usage — the round path, compaction, command
+// routing and failure diagnosis all do — so the bench reads the same record the
+// product reads instead of wrapping a provider and counting a second time.
+type usageSink struct {
+	mu       sync.Mutex
+	requests int
+	usage    provider.Usage
+}
+
+func (s *usageSink) Emit(e event.Event) {
+	if e.Kind != event.Usage || e.Usage == nil {
+		return
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	// One event is one completion that reported usage; RequestCount covers a
+	// completion that merged attempts. A request that failed before reporting
+	// leaves no event, so this is not a count of attempts.
+	if e.Usage.RequestCount > 0 {
+		s.requests += e.Usage.RequestCount
+	} else {
+		s.requests++
+	}
+	u := *e.Usage
+	s.usage.PromptTokens += u.PromptTokens
+	s.usage.CompletionTokens += u.CompletionTokens
+	s.usage.TotalTokens += u.TotalTokens
+	s.usage.CacheHitTokens += u.CacheHitTokens
+	s.usage.CacheMissTokens += u.CacheMissTokens
+	s.usage.ReasoningTokens += u.ReasoningTokens
+	s.usage.Estimated = s.usage.Estimated || u.Estimated
+}
+
+func (s *usageSink) snapshot() (provider.Usage, int) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.usage, s.requests
+}
+
+// promptTokenSuffix renders what a run cost only when something reported it. A
+// dry run reports nothing, and a trailing "prompt-tok=0" would read as a
+// measured zero rather than as no measurement.
+func promptTokenSuffix(m contextMetrics) string {
+	if m.UsageReportedRequests == 0 {
+		return ""
+	}
+	return fmt.Sprintf(" prompt-tok=%d", m.PromptTokens)
+}

benchmarks/context-retrieval/usage_test.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"testing"
+
+	"reasonix/internal/contract/event"
+	"reasonix/internal/contract/provider"
+)
+
+// The cost a run reports must be what the agent reported, summed across every
+// completion it billed — including one that merged attempts and one that could
+// only estimate. Any other event kind is not a cost.
+func TestUsageSinkAccumulatesWhatTheAgentReports(t *testing.T) {
+	var sink usageSink
+	sink.Emit(event.Event{}) // a kind that is not Usage
+	sink.Emit(event.Event{Kind: event.Usage, Usage: &provider.Usage{
+		PromptTokens: 100, CompletionTokens: 10, TotalTokens: 110, CacheHitTokens: 60, CacheMissTokens: 40,
+	}})
+	sink.Emit(event.Event{Kind: event.Usage, Usage: &provider.Usage{
+		PromptTokens: 7, CompletionTokens: 3, CacheHitTokens: 2, CacheMissTokens: 5, RequestCount: 2, Estimated: true,
+	}})
+	sink.Emit(event.Event{Kind: event.Usage}) // a Usage event with no payload is not a cost
+
+	usage, requests := sink.snapshot()
+	if requests != 3 {
+		t.Fatalf("requests = %d, want 3 (1 + the merged attempt's 2; the empty event adds none)", requests)
+	}
+	if usage.PromptTokens != 107 || usage.CompletionTokens != 13 || usage.TotalTokens != 110 {
+		t.Fatalf("accumulated usage = %+v", usage)
+	}
+	if usage.CacheHitTokens != 62 || usage.CacheMissTokens != 45 {
+		t.Fatalf("cache split = %+v", usage)
+	}
+	if !usage.Estimated {
+		t.Fatal("Estimated was dropped when one completion reported an estimate")
+	}
+}
+
+// A dry run must not claim a cost it never paid, in the JSON or in the line a
+// person reads: an empty suffix, not "prompt-tok=0".
+func TestUsageSinkStaysEmptyWithoutUsage(t *testing.T) {
+	var sink usageSink
+	sink.Emit(event.Event{})
+	usage, requests := sink.snapshot()
+	if requests != 0 || usage.PromptTokens != 0 || usage.CompletionTokens != 0 {
+		t.Fatalf("nothing reported usage, got %+v requests=%d", usage, requests)
+	}
+	if suffix := promptTokenSuffix(contextMetrics{}); suffix != "" {
+		t.Fatalf("a run with no reported usage still printed %q", suffix)
+	}
+	if suffix := promptTokenSuffix(contextMetrics{UsageReportedRequests: 1, PromptTokens: 12}); suffix != " prompt-tok=12" {
+		t.Fatalf("a reported cost printed %q", suffix)
+	}
+}

benchmarks/intelligent-ui/README.md

@@ -1,87 +0,0 @@
-# Desktop surface evaluation
-
-This protocol supplies the fixed-task trajectory comparison required by
-[RFC #12584](https://github.com/esengine/DeepSeek-Reasonix/issues/12584).
-There are no measured results yet. Component tests and scripted providers prove
-delivery, validation and replay; they do not measure a model's choice of interface
-or a person's effort.
-
-## Paired runs
-
-Run each task twice in fresh desktop sessions: ordinary text/ask interaction and
-native surfaces. Use the same model, sampling settings, initial workspace,
-permission mode and task prompt. Record commit, model, configuration and the
-native-surface capability setting. Alternate condition order across repetitions.
-Keep the hidden tool out of the provider prefix in both conditions; only its
-availability through capability discovery differs.
-
-The baseline may batch questions or accept a single text reply. Never force it to
-ask one question per field. Do not tell either model how many turns to use or
-which component to render. If the surface-enabled model chooses text, retain
-that run in the surface condition. Interface choice is part of the experiment.
-
-The operator knows the private values below but does not volunteer them before
-the model requests the corresponding information. Supply all requested values
-together, regardless of presentation. Allow inspection and local editing before
-submission. Save the trajectory and an observer ledger locally; raw transcripts
-and draft content must not enter the aggregate report.
-
-## Fixed tasks
-
-| Task | Initial prompt, identical in both conditions | Private operator input | Completion criterion |
-| --- | --- | --- | --- |
-| `release-brief` | Prepare a release brief. Ask me for the audience, release date and whether this is a staged rollout before writing it. | audience: existing desktop users; date: 2026-11-03; staged rollout: yes | Final brief contains all three values and adds no release commitment. |
-| `storage-choice` | Help me choose storage for a small desktop app. Present reasonable choices, ask me to choose and ask whether offline operation is required. Then summarize the decision. | storage: SQLite; offline: yes | Final decision states SQLite and offline operation, with no installation or file changes. |
-| `draft-revision` | Draft a two-line release announcement and let me revise it before returning the final version verbatim. | Replace with the exact string `  Desktop release ready.\nKeep existing settings.\n` (decode the escapes). | Final returned string has exactly the specified leading spaces and newlines. Formatting wrappers are excluded from the comparison. |
-| `preview-decision` | Show a plain-text before/after preview changing retry count from 2 to 3. Ask whether to keep that change and whether to include a release note. Return a decision summary; do not change files. | keep change: yes; release note: no | Preview shows 2 to 3; final summary preserves both decisions; workspace is unchanged. |
-
-Freeze this task set before collecting results. Record a new protocol version if
-prompts, private inputs, completion criteria or metric definitions change.
-Neither the model's final claim nor a successful input acknowledgment establishes
-completion. The observer checks the resulting output against the criterion.
-
-## Metric definitions (version 1)
-
-The anchor is acknowledgment of the initial task prompt. The observation ends
-when the criterion is verified, the operator abandons the task, or the run fails.
-The initial prompt is excluded from subsequent-input counts because both
-conditions start from the same request.
-
-| Metric | Count and population | Exclusions |
-| --- | --- | --- |
-| `acknowledged_inputs` | Distinct operator submissions acknowledged after the anchor: chat replies, ask answers, surface answers and surface actions. Includes acknowledged input later withdrawn or superseded. | Initial task prompt, local draft edits, retries with the same acknowledged request identity, automatic dispatch, replay and observer grading. This counts input exchanges, not provider rounds. |
-| `submission_attempts` | Explicit operator send attempts, including rejected submissions and manual retries. | Automatic transport retries, replay, local edits and model tool calls. |
-| `withdrawals` | Successful operator withdrawals of admitted input. | Failed withdrawals, automatic cancellation and replay. |
-| `completed` | Runs whose output meets the fixed criterion. Denominator: every started run in each condition. | None; failures and abandoned runs remain in the denominator. |
-
-Record these in a content-free ledger: task id, repetition, condition, observer
-event ordinal, event type, opaque request identity, acknowledgment status and
-completion verdict. Record the source trajectory reference and observed start
-and end anchors alongside it. Distinguish manual observation from host-recorded
-events. Do not copy labels, prompts, private values, drafts or answer strings into
-the ledger. Identities are local correlation handles, not account identifiers.
-
-The current pane counters and rendered trajectory export cannot reconstruct all
-acknowledgments, refusals and withdrawals. Do not infer them from `ask` calls,
-tool-result counts, final prose, message wording or card mounts. Until structural
-acknowledgment records cover every channel, an observer ledger is required.
-
-## Report and decision
-
-Report the number started, completed, failed and abandoned for each condition,
-then paired input-count differences for repetitions where **both** conditions
-meet the same criterion. List excluded pairs and their reason beside that
-comparison. Also report submission attempts and withdrawals; fewer admitted
-inputs with more failures is not automatically less effort.
-
-Keep per-task results visible. Do not combine scripted fixtures with observed
-model/operator runs or describe this small task set as an account-wide result.
-Report model/configuration differences and missing evidence as limitations.
-
-The RFC's benefit remains unproven until observed trajectories show fewer input
-exchanges to the same verified outcome. These results alone do not justify P3;
-adaptive layout or MCP Apps needs a measured problem in addition to this result.
-
-The owner-requested map, comparison and dashboard workspaces extend the delivery
-scope independently of this study. Their scripted acceptance fixtures verify
-rendering and interaction only; they do not count as observed benefit evidence.

benchmarks/realrepo/README.md

@@ -1,131 +0,0 @@
-# realrepo
-
-Long tasks over a pinned snapshot of this repository, for measuring changes
-that aim to cut model round trips. The `benchmarks/e2e` tasks finish in about
-5–15 requests and ten seconds; a real task in this tree took a flash-class
-model 38 requests, most of them after a single read. A suite of short fixtures
-cannot show that gap moving, so these tasks are shaped like the real one:
-explore several packages, edit several files, verify, and recover from the
-verifier.
-
-```sh
-go build -o bin/reasonix ./cmd/reasonix
-go run ./cmd/e2ebench -suite benchmarks/realrepo -bin "$PWD/bin/reasonix" -model deepseek-flash \
-  -budget 0 -trials 2 -trajectories traj -json realrepo.json
-go run ./cmd/e2ebench -suite benchmarks/realrepo -bin "$PWD/bin/reasonix" -task rt-stale-skills
-```
-
-The agent reads its provider config from `REASONIX_HOME` (default
-`~/.reasonix`); point it at a disposable one to keep benchmark sessions out of
-your own.
-
-The default `-budget` (800k tokens) can stop the suite partway through, hence
-`-budget 0`. Under `-trials`, each trial keeps its own
-`<task>.trial-N.trajectory.jsonl`.
-
-## The snapshot
-
-Every `workdir/` is the same Go module (`module reasonix`, stdlib only, no
-network needed to build or test):
-
-- **Pinned code.** `git archive` of commit `42636ddcb425` for
-  `internal/contract/{pricing,ablation,agentgraph}` and
-  `internal/base/{retrieval,rulelist,tokencount,neterr,nilutil}` — about 5k
-  lines of real kernel code with its real tests and doc comments.
-- **Fixture-authored files** in `base/`: `go.mod`, a trimmed `REASONIX.md` (the
-  project's own conventions, so the agent loads standing instructions the way
-  it does here), a `Makefile` with `check`, a module `README.md`, the
-  `cmd/benchctl` command that consumes `pricing` and `ablation` from outside
-  their package, and one project skill.
-- **One pinned test anchored to the snapshot day.**
-  `TestCatalogPricesHaveBeenCheckedRecently` compares each row's `CheckedOn`
-  with the wall clock, which would fail every workdir 90 days after the oldest
-  pinned date (2026-11-20). `base/` replaces that file with one that reads
-  staleness at 2026-10-19 instead; nothing else in the pin is edited.
-- **Per-task overlay** in `overlay/<task-id>/`, applied last. Only
-  `rt-stale-skills` has one.
-
-`snapshot.sh` rebuilds every workdir from those three sources and
-`snapshot.sh --check` fails if a committed workdir has drifted from them. Edit
-`base/` or `overlay/`, never a workdir, then rerun the script. Moving the pin is
-a new suite version: results from two pins do not compare.
-
-## Tasks
-
-| Task | Kind | What it exercises |
-| --- | --- | --- |
-| `rt-cache-write-rate` | multi-file Go change, test, README | Adds a `CacheWrite` rate to `RateCard` and threads it through cost, fingerprint, card identity and the catalog, then prices Anthropic's `claude-sonnet-4-5` with it: a new `officialRates` row, documentation and checked-on constants, an endpoint host, and `benchctl rate`/`cost` output. The fingerprint has to stay byte-identical for every existing card, so the change to `PricingFingerprint` cannot be the obvious one. |
-| `rt-stale-skills` | documentation only, no recognised verifier | Three project skills name paths, functions, `make` targets and `benchctl` subcommands and flags that do not exist, and one contradicts the append-only rule in `REASONIX.md`. Fixing them takes reading `rates.go`, `ablation.go`, both `benchctl` files and the `Makefile`, then editing only Markdown — the shape behind #13293, where `stale_verification` stays owed after a skill edit because no check covers it. |
-| `rt-rate-lookup-signatures` | API migration with a likely compile-error loop | Changes `CurrentRate` to `(RateCard, bool)`, `LookupCatalog` to a `CatalogKey` struct, and `IsOfficialCard`, `MatchesCatalog` and `LiveTariff` to a `ModelRef`: about 20 call sites across 11 files. Most are in `_test.go` files and dereference the old pointer, so `go build ./...` can pass while `go vet` and `go test` fail. |
-| `rt-plan-ablation-module` | plan-mode with `complete_step` | Five numbered steps adding a `memory` ablation module, summaries, `ModuleHelp` and `benchctl arm -list`. The prompt opens with the host's own plan-first marker (`control.PlannerRouteMarker`), which routes the turn through the planner, and asks for each step to be signed off before the next. An existing test pins the `all` arm name and has to be updated, which adds a red-test step. |
-
-Every grader stages hidden tests and checks after the run: `gofmt -l`, `go vet
-./...` and `go test ./...` for the Go tasks; for `rt-stale-skills`, every
-backticked path, identifier, `make` target and `benchctl` command line in each
-skill must resolve against the tree, and a SHA-256 manifest proves no Go source, `go.mod`,
-`Makefile` or `REASONIX.md` changed. Each task fails its pristine seed and
-passes its `solution/`, both checked by `cmd/e2ebench`'s corpus tests.
-
-## Reading the numbers
-
-```text
-Metric:        requests per task
-Anchor:        the trajectory digest's requests_by_source, summed over sources
-Population:    every graded trial of a task that ran to its own stop
-Excludes:      tasks the token budget skipped, and runs that hit timeout_sec
-```
-
-Requests is the headline because round trips are what these tasks exist to
-move. Read it beside the solve rate and the report's round outcomes: a change
-that drops requests by giving up on verification has not cut a round trip, it
-has cut a check. `rt-stale-skills` is read for whether the run finishes at all
-and how many rounds go to re-verifying after its last write.
-
-## Baseline
-
-`deepseek-flash`, 2 trials per task, at studio `0b8de9e63`. Requests are the
-trajectory's executor requests; all 8 runs ran to their own stop.
-
-| Task | Solved | Requests | `edit_file` calls | Edit rounds |
-| --- | --- | --- | --- | --- |
-| `rt-cache-write-rate` | 2/2 | 31, 28 | 21, 20 | 8, 8 |
-| `rt-plan-ablation-module` | 2/2 | 24, 30 | 10, 13 | 9, 7 |
-| `rt-rate-lookup-signatures` | 2/2 | 13, 15 | 10, 17 | 2, 6 |
-| `rt-stale-skills` | 2/2* | 20, 26 | 3, 2 | 3, 3 |
-
-\* One run first graded as failed, on a glob (`*_rates_test.go`) and a
-placeholder (`benchctl <subcommand>`) that were both correct. The grader now
-resolves globs against the tree and skips placeholders, and that run counts
-as solved. The same task's first version failed a run for naming
-`CatalogEntry.EffectiveFrom` in order to warn against it; that check went too.
-
-Reads and edits already batch: 20 edit calls fit into 8 rounds, and several
-`edit_file` calls to one file often share a round. Rounds that edit a file the
-previous round also edited are rare (0–2 per run), so steering same-file edits
-to `multi_edit` has little to save. On this suite's first version, a
-`ToolBatchPolicy` sentence asking for it drew no `multi_edit` call and 167
-requests against 158.
-
-`rt-plan-ablation-module` spends five rounds per run on `complete_step` alone.
-A description change inviting the sign-off to share the next step's reply was
-taken up in 2 of 4 trials (4 of 5 sign-offs shared each time, against 0 of 20
-in control), and requests did not move: 30, 25, 21, 28 against 27, 23, 24, 30.
-At this spread, four trials per arm cannot show a saving of a few rounds.
-
-## Gaps
-
-- **Below the intended size, in places.** The tasks were designed for 25–50
-  requests. After widening, the median is 25, but `rt-rate-lookup-signatures`
-  still runs 13–15: the model greps every call site first and batches the edits,
-  so even about 20 call sites cost few rounds, and no run hit a compile-error
-  loop.
-- **Lexical grader.** `rt-stale-skills` judges Markdown by resolving what it
-  names. It has misjudged correct text twice (see the baseline note); a new
-  failure there should be read before it is counted.
-- **No git history.** The workdir is a plain directory: `git diff`, `git log`
-  and `git status` have nothing to read, so runs that lean on them in this tree
-  behave differently here.
-- **Plan marker and `-force-planner`.** `rt-plan-ablation-module` carries the
-  plan-first marker in its prompt, so it engages the planner in every arm,
-  including runs without `-force-planner`. Exclude it when comparing planner
-  arms.

benchmarks/realrepo/base/.reasonix/skills/price-change/SKILL.md

@@ -1,18 +0,0 @@
----
-name: price-change
-description: Record a vendor's announced price change in the official price book without losing the rate it replaces.
----
-
-# Recording a price change
-
-1. Find the vendor's rows in `officialRates` in
-   `internal/contract/pricing/rates.go`. Each row is one model in one currency.
-2. **Append** a `rateGeneration` to the row's `Rates`; never edit an existing
-   one. Set `From` to the first billed day (`YYYY-MM-DD`, UTC) when the change
-   is announced ahead of time.
-3. Leave the earlier generation where it is: `SupersededRates` reads it so a
-   stored price that matches it is recognised as ours and refreshed.
-4. Update the row's `CheckedOn` constant to the day you confirmed the page.
-5. Add a test beside `rates_test.go` that pins `CurrentRate` before and after
-   the `From` day by replacing `today`.
-6. Run `make check`. `make pricecheck` needs the network and is run by hand.

benchmarks/realrepo/base/Makefile

@@ -1,17 +0,0 @@
-.PHONY: check test vet fmt pricecheck
-
-check: fmt vet test
-
-fmt:
-	@out="$$(gofmt -l .)"; if [ -n "$$out" ]; then echo "gofmt needed:"; echo "$$out"; exit 1; fi
-
-vet:
-	go vet ./...
-
-test:
-	go test ./...
-
-# Reads each vendor's pricing page; this snapshot carries no network client.
-pricecheck:
-	@echo "pricecheck: reaches each vendor's pricing page and needs the network; not available in this snapshot" >&2
-	@exit 2

benchmarks/realrepo/base/README.md

@@ -1,69 +0,0 @@
-# Reasonix kernel snapshot
-
-A trimmed slice of the Reasonix Go kernel: the contracts a benchmark report is
-priced and labelled with, a few leaf utilities, and `benchctl`, a small command
-that prints what those contracts answer.
-
-```bash
-make check                                   # gofmt, vet, test
-go run ./cmd/benchctl rate -model deepseek-flash -currency USD
-go run ./cmd/benchctl cost -provider mimo -model mimo-v2.5 -miss 1000000
-go run ./cmd/benchctl tariff -currency CNY -at 2026-10-12T02:00:00Z
-go run ./cmd/benchctl arm -ablate planner,evidence
-```
-
-## Packages
-
-| Package | Owns |
-| --- | --- |
-| `internal/contract/pricing` | the official price book, cost quotes, the spend ledger |
-| `internal/contract/ablation` | which subsystems a benchmark arm switches off, and the arm's name |
-| `internal/contract/agentgraph` | the vocabulary of one run's execution graph |
-| `internal/base/retrieval` | BM25 ranking over CJK-aware tokens |
-| `internal/base/rulelist` | splitting a one-line permission rule list |
-| `internal/base/tokencount` | a cheap token estimate |
-| `internal/base/neterr` | classifying transport errors |
-| `internal/base/nilutil` | typed-nil detection |
-| `cmd/benchctl` | prints rates, costs, peak schedules and arm names |
-
-## Pricing
-
-A `RateCard` is a price per million tokens in one currency:
-
-| Field | Charges |
-| --- | --- |
-| `CacheHit` | prompt tokens served from the provider's cache |
-| `Input` | prompt tokens that missed the cache, including tokens written to it |
-| `Output` | completion tokens |
-
-`OriginalCostAmount` turns a card and a `UsageTokens` breakdown into a
-fixed-point `Amount`; `PricingFingerprint` keys a card in the ledger, so a
-stored ledger entry stays attached to the card it was priced with.
-`CurrentRate` and `SupersededRates` answer from `officialRates`, which only
-ever grows: a price change appends a generation.
-
-## Ablation
-
-`ablation.Parse` reads a comma-separated list of modules to switch off, and
-`Set.Arm` names the result (`full` for the control). The switchable modules,
-in the order arm names use:
-
-| Module | Off means |
-| --- | --- |
-| `evidence` | no evidence gate on completion claims |
-| `planner` | no two-model planning turn |
-| `subagent` | no delegation to workers |
-| `retrieval` | no retrieval over the folded transcript |
-| `compaction` | no context folding |
-| `upstream` | a dependency edge orders its endpoints without delivering the answer |
-| `recall-search` | recall can read a given address but cannot search for one |
-
-The fold-index scale is a separate axis (`-fold-index`), not a module.
-
-## Skills
-
-Project skills live under `.reasonix/skills/<name>/SKILL.md`.
-
-| Skill | Use it to |
-| --- | --- |
-| `price-change` | record a vendor's price change in the price book |

benchmarks/realrepo/base/REASONIX.md

@@ -1,51 +0,0 @@
-# Reasonix project memory
-
-This checkout is a trimmed snapshot of the Reasonix kernel: the billing,
-ablation and graph contracts and a handful of leaf utilities, plus one small
-command that drives them. The conventions below are the project's own.
-
-## Conventions
-
-- Go kernel under `internal/`; each package owns one concern. A package's long
-  explanation belongs in its `doc.go`, not spread across implementation files.
-- Judgements read structure, never wording: types, contracts, schemas. An
-  error a caller must tell apart carries an identity — a sentinel, a typed
-  code — never a sentence.
-- A metric is its definition, not its name. Before a number becomes a finding,
-  state what it counts, from which anchor, over which population, and what it
-  excludes.
-
-## Comments
-
-Default is none — the code is the truth. Write one only when the **why** is
-non-obvious: a hidden constraint, an invariant the type system cannot express,
-or an external-protocol quirk. A comment states the constraint that holds now;
-it does not narrate how the code got here. English, always.
-
-- Declaration doc: ≤5 lines. Package comment: ≤8 lines, or ≤40 in a `doc.go`.
-- Every other comment: ≤3 lines. Struct-field and trailing `//`: 1 line.
-- One responsibility per file; 800 lines is the ceiling.
-
-## Vendor rates
-
-Official list prices live in one place: `officialRates` in
-`internal/contract/pricing/rates.go`, oldest generation first, the last being
-what a model charges today. A price change is an **append, never an edit** —
-the superseded rate is what lets an installed config be recognised as holding
-one of ours and brought forward. Callers read these through
-`pricing.CurrentRate` and `pricing.SupersededRates` and restate none of them.
-
-`make pricecheck` compares that table against each vendor's own page. It needs
-the network, so it is not part of `make check`.
-
-## Before every commit
-
-```bash
-make check    # gofmt -l, go vet ./..., go test ./...
-```
-
-## Change discipline
-
-List callers, consumers of the same state and sibling features before editing.
-Fix at the owning layer; a fix that breaks a neighbouring behaviour is a failed
-fix. Write tests first; they must fail without the change.

benchmarks/realrepo/base/cmd/benchctl/main.go

@@ -1,115 +0,0 @@
-// Command benchctl prints what the pricing and ablation contracts answer for
-// one model or one benchmark arm, so a reviewer can check a rate or an arm name
-// without writing a test.
-package main
-
-import (
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-
-	"reasonix/internal/contract/ablation"
-	"reasonix/internal/contract/pricing"
-)
-
-var errUsage = errors.New("usage: benchctl rate|cost|tariff|arm [flags]")
-
-func main() {
-	if err := run(os.Args[1:], os.Stdout); err != nil {
-		fmt.Fprintln(os.Stderr, "benchctl:", err)
-		os.Exit(2)
-	}
-}
-
-func run(args []string, out io.Writer) error {
-	if len(args) == 0 {
-		return errUsage
-	}
-	switch args[0] {
-	case "rate":
-		return runRate(args[1:], out)
-	case "cost":
-		return runCost(args[1:], out)
-	case "tariff":
-		return runTariff(args[1:], out)
-	case "arm":
-		return runArm(args[1:], out)
-	default:
-		return fmt.Errorf("%w: unknown subcommand %q", errUsage, args[0])
-	}
-}
-
-func runRate(args []string, out io.Writer) error {
-	fs := flag.NewFlagSet("rate", flag.ContinueOnError)
-	fs.SetOutput(out)
-	provider := fs.String("provider", "deepseek", "vendor")
-	model := fs.String("model", "deepseek-flash", "model id")
-	currency := fs.String("currency", "", "currency; empty reads the vendor's default")
-	if err := fs.Parse(args); err != nil {
-		return err
-	}
-	cur := *currency
-	if cur == "" {
-		cur = pricing.DefaultCurrency(*provider)
-	}
-	card := pricing.CurrentRate(*provider, *model, cur)
-	if card == nil {
-		return fmt.Errorf("no official rate for %s/%s in %s", *provider, *model, cur)
-	}
-	fmt.Fprintf(out, "%s/%s %s: cache-hit %g input %g output %g per 1M\n",
-		*provider, *model, card.Currency, card.CacheHit, card.Input, card.Output)
-	if entry, ok := pricing.LookupCatalog(*provider, *model, cur, ""); ok && entry.DocURL != "" {
-		fmt.Fprintf(out, "source: %s\n", entry.DocURL)
-	}
-	fmt.Fprintf(out, "superseded generations: %d\n", len(pricing.SupersededRates(*provider, *model, cur)))
-	return nil
-}
-
-func runCost(args []string, out io.Writer) error {
-	fs := flag.NewFlagSet("cost", flag.ContinueOnError)
-	fs.SetOutput(out)
-	provider := fs.String("provider", "deepseek", "vendor")
-	model := fs.String("model", "deepseek-flash", "model id")
-	currency := fs.String("currency", "", "currency; empty reads the vendor's default")
-	hit := fs.Int("hit", 0, "cached prompt tokens")
-	miss := fs.Int("miss", 0, "uncached prompt tokens")
-	completion := fs.Int("completion", 0, "completion tokens")
-	if err := fs.Parse(args); err != nil {
-		return err
-	}
-	cur := *currency
-	if cur == "" {
-		cur = pricing.DefaultCurrency(*provider)
-	}
-	card := pricing.CurrentRate(*provider, *model, cur)
-	if card == nil {
-		return fmt.Errorf("no official rate for %s/%s in %s", *provider, *model, cur)
-	}
-	usage := pricing.UsageTokens{CacheHitTokens: *hit, CacheMissTokens: *miss, CompletionTokens: *completion}
-	amount := pricing.OriginalCostAmount(*card, usage)
-	fmt.Fprintf(out, "%s %s\n", amount, pricing.NormalizeCurrency(card.Currency))
-	return nil
-}
-
-func runArm(args []string, out io.Writer) error {
-	fs := flag.NewFlagSet("arm", flag.ContinueOnError)
-	fs.SetOutput(out)
-	spec := fs.String("ablate", "", "comma-separated modules to switch off: "+ablation.ModuleList())
-	foldIndex := fs.String("fold-index", "", "fold-index scale: default, half, quarter or off")
-	list := fs.Bool("list", false, "list the switchable modules")
-	if err := fs.Parse(args); err != nil {
-		return err
-	}
-	if *list {
-		fmt.Fprintln(out, ablation.ModuleList())
-		return nil
-	}
-	set, err := ablation.ParseArm(*spec, *foldIndex)
-	if err != nil {
-		return err
-	}
-	fmt.Fprintln(out, set.Arm())
-	return nil
-}

benchmarks/realrepo/base/cmd/benchctl/main_test.go

@@ -1,65 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"errors"
-	"strings"
-	"testing"
-)
-
-func runOut(t *testing.T, args ...string) string {
-	t.Helper()
-	var out bytes.Buffer
-	if err := run(args, &out); err != nil {
-		t.Fatalf("run %v: %v", args, err)
-	}
-	return out.String()
-}
-
-func TestRateNamesTheCurrentCard(t *testing.T) {
-	got := runOut(t, "rate", "-provider", "mimo", "-model", "mimo-v2.5")
-	if !strings.Contains(got, "mimo/mimo-v2.5 CNY: cache-hit 0.02 input 1 output 2 per 1M") {
-		t.Fatalf("rate output = %q", got)
-	}
-}
-
-func TestRateRefusesAnUnpricedModel(t *testing.T) {
-	var out bytes.Buffer
-	if err := run([]string{"rate", "-provider", "nobody", "-model", "x"}, &out); err == nil {
-		t.Fatal("an unpriced model must fail")
-	}
-}
-
-func TestCostChargesTheCurrentCard(t *testing.T) {
-	got := runOut(t, "cost", "-provider", "mimo", "-model", "mimo-v2.5", "-miss", "1000000", "-completion", "1000000")
-	if strings.TrimSpace(got) != "3 CNY" {
-		t.Fatalf("cost output = %q", got)
-	}
-}
-
-func TestArmNamesTheConfiguration(t *testing.T) {
-	if got := strings.TrimSpace(runOut(t, "arm")); got != "full" {
-		t.Fatalf("control arm = %q", got)
-	}
-	if got := strings.TrimSpace(runOut(t, "arm", "-ablate", "planner,evidence", "-fold-index", "half")); got != "no-evidence+no-planner+index-half" {
-		t.Fatalf("arm = %q", got)
-	}
-}
-
-func TestUnknownSubcommandIsAUsageError(t *testing.T) {
-	var out bytes.Buffer
-	if err := run([]string{"nope"}, &out); !errors.Is(err, errUsage) {
-		t.Fatalf("err = %v, want errUsage", err)
-	}
-}
-
-func TestTariffReadsTheVendorsSchedule(t *testing.T) {
-	got := runOut(t, "tariff", "-provider", "mimo", "-model", "mimo-v2.5")
-	if !strings.Contains(got, "official card: true") || !strings.Contains(got, "one rate around the clock") {
-		t.Fatalf("tariff output = %q", got)
-	}
-	peak := runOut(t, "tariff", "-currency", "CNY", "-at", "2026-10-12T02:00:00Z")
-	if !strings.Contains(peak, "peak=true until 2026-10-12T04:00:00Z") {
-		t.Fatalf("deepseek tariff at a weekday peak = %q", peak)
-	}
-}

benchmarks/realrepo/base/cmd/benchctl/tariff.go

@@ -1,49 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"io"
-	"time"
-
-	"reasonix/internal/contract/pricing"
-)
-
-func runTariff(args []string, out io.Writer) error {
-	fs := flag.NewFlagSet("tariff", flag.ContinueOnError)
-	fs.SetOutput(out)
-	provider := fs.String("provider", "deepseek", "vendor")
-	model := fs.String("model", "deepseek-flash", "model id")
-	currency := fs.String("currency", "", "currency; empty reads the vendor's default")
-	at := fs.String("at", "", "instant to read the schedule at, RFC 3339; empty is now")
-	if err := fs.Parse(args); err != nil {
-		return err
-	}
-	when := time.Now()
-	if *at != "" {
-		t, err := time.Parse(time.RFC3339, *at)
-		if err != nil {
-			return fmt.Errorf("-at: %w", err)
-		}
-		when = t
-	}
-	cur := *currency
-	if cur == "" {
-		cur = pricing.DefaultCurrency(*provider)
-	}
-	card := pricing.CurrentRate(*provider, *model, cur)
-	if card == nil {
-		return fmt.Errorf("no official rate for %s/%s in %s", *provider, *model, cur)
-	}
-	fmt.Fprintf(out, "official card: %v\n", pricing.IsOfficialCard(*provider, *model, *card))
-	tariff, ok := pricing.LiveTariff(*provider, *model, *card, when)
-	switch {
-	case !ok:
-		fmt.Fprintln(out, "schedule: one rate around the clock")
-	case !tariff.Changes:
-		fmt.Fprintf(out, "schedule: peak=%v, no change ahead\n", tariff.Peak)
-	default:
-		fmt.Fprintf(out, "schedule: peak=%v until %s\n", tariff.Peak, tariff.ChangesAt.UTC().Format(time.RFC3339))
-	}
-	return nil
-}

benchmarks/realrepo/base/go.mod

@@ -1,3 +0,0 @@
-module reasonix
-
-go 1.26.0

benchmarks/realrepo/base/internal/contract/pricing/catalog_test.go

@@ -1,95 +0,0 @@
-package pricing
-
-import (
-	"strings"
-	"testing"
-	"time"
-)
-
-// Every catalog provider must declare at least one official endpoint, or its
-// rows become unreachable: a rate card is only matched against the catalog
-// after the entry's host identifies the vendor.
-func TestEveryCatalogProviderHasAnOfficialEndpoint(t *testing.T) {
-	declared := map[string]bool{}
-	for _, host := range officialEndpointHosts {
-		declared[host] = true
-	}
-	for _, entry := range OfficialCatalog() {
-		if !declared[entry.Provider] {
-			t.Errorf("catalog provider %q has no official endpoint host; its prices can never match", entry.Provider)
-		}
-	}
-}
-
-func TestOfficialProviderForEndpoint(t *testing.T) {
-	cases := []struct {
-		name    string
-		baseURL string
-		want    string
-	}{
-		{"official deepseek", "https://api.deepseek.com", "deepseek"},
-		{"official deepseek anthropic path", "https://api.deepseek.com/anthropic", "deepseek"},
-		{"official longcat", "https://api.longcat.chat/openai/v1", "longcat"},
-		{"official mimo region", "https://token-plan-sgp.xiaomimimo.com/v1", "mimo"},
-		{"uppercase host", "https://API.DeepSeek.com/v1", "deepseek"},
-		{"proxy that resells the model", "https://my-deepseek-proxy.internal/v1", ""},
-		{"vendor name in the path only", "https://gateway.example.com/deepseek/v1", ""},
-		{"lookalike registrable domain", "https://api.deepseek.com.evil.test/v1", ""},
-		{"empty", "", ""},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := OfficialProviderForEndpoint(tc.baseURL); got != tc.want {
-				t.Fatalf("OfficialProviderForEndpoint(%q) = %q, want %q", tc.baseURL, got, tc.want)
-			}
-		})
-	}
-}
-
-// pricesGoStaleAfter is how long a hand-copied rate is trusted before someone
-// reads the vendor's page again. No vendor here serves prices over an API, so
-// the alternative to this going red on a quiet day is learning about a change
-// from a user whose cost was wrong for months. Bumping CheckedOn without
-// opening DocURL defeats it; what this buys is that the question gets asked.
-const pricesGoStaleAfter = 90 * 24 * time.Hour
-
-func TestCatalogPricesHaveBeenCheckedRecently(t *testing.T) {
-	var undated, stale []string
-	// This snapshot never sees a vendor page again, so staleness is read at the
-	// day it was taken rather than the day the suite runs.
-	cutoff := time.Date(2026, 10, 19, 0, 0, 0, 0, time.UTC).Add(-pricesGoStaleAfter)
-	for _, e := range OfficialCatalog() {
-		where := e.Provider + "/" + e.Model + " " + e.Currency + " (" + e.DocURL + ")"
-		if e.CheckedOn == "" {
-			undated = append(undated, where)
-			continue
-		}
-		on, err := time.Parse("2006-01-02", e.CheckedOn)
-		if err != nil {
-			t.Fatalf("%s: CheckedOn %q is not YYYY-MM-DD", where, e.CheckedOn)
-		}
-		if on.Before(cutoff) {
-			stale = append(stale, where+" last checked "+e.CheckedOn)
-		}
-	}
-	if len(undated) > 0 {
-		t.Errorf("catalog rows with no CheckedOn — read the vendor's page and date them:\n  %s",
-			strings.Join(undated, "\n  "))
-	}
-	if len(stale) > 0 {
-		t.Errorf("catalog rows older than %d days. Open each DocURL, confirm or correct the rate, then set CheckedOn to today:\n  %s",
-			int(pricesGoStaleAfter.Hours()/24), strings.Join(stale, "\n  "))
-	}
-}
-
-// A row that names a peak card must say when it applies, and one that names a
-// window must have a card to charge inside it. Half of the pair silently prices
-// every hour the same, which is the bug the pair exists to prevent.
-func TestPeakRatesAndWindowsComeInPairs(t *testing.T) {
-	for _, e := range OfficialCatalog() {
-		where := e.Provider + "/" + e.Model + " " + e.Currency
-		if (e.Peak == nil) != (e.Window == nil) {
-			t.Errorf("%s: Peak and Window must be set together (peak=%v window=%v)", where, e.Peak != nil, e.Window != nil)
-		}
-	}
-}

benchmarks/realrepo/overlay/rt-stale-skills/.reasonix/skills/ablation-arm/SKILL.md

@@ -1,12 +0,0 @@
----
-name: ablation-arm
-description: Add a new switchable subsystem to the benchmark's ablation arms.
----
-
-# Adding an ablation module
-
-1. Declare the module in `internal/ablation/modules.go` beside the others.
-2. Register it in `AllModules()` so `ParseSpec` accepts it.
-3. Arm names come from `Set.Name()`; check that yours reads `without-<module>`.
-4. Add the module to the flag help text in `cmd/bench/flags.go`.
-5. Run `make test`.

benchmarks/realrepo/overlay/rt-stale-skills/.reasonix/skills/benchctl/SKILL.md

@@ -1,15 +0,0 @@
----
-name: benchctl
-description: Check a rate, a cost, a peak schedule or an arm name from the command line instead of writing a test.
----
-
-# Using benchctl
-
-1. Price a request with `benchctl quote -provider mimo -model mimo-v2.5 -tokens 1000000`;
-   it prints the amount and the currency.
-2. Read today's card with `benchctl rate -vendor deepseek -model deepseek-flash`.
-3. Ask whether a vendor is in its peak window with
-   `benchctl peak -currency CNY -at 1791770400` (Unix seconds).
-4. List the ablation modules with `benchctl arms`, and name an arm with
-   `benchctl arm -ablate planner,evidence -index half`.
-5. Every subcommand prints its flags with `-h`.

benchmarks/realrepo/overlay/rt-stale-skills/.reasonix/skills/price-change/SKILL.md

@@ -1,13 +0,0 @@
----
-name: price-change
-description: Record a vendor's announced price change in the official price book.
----
-
-# Recording a price change
-
-1. Open `internal/pricing/rates.go` and find the vendor's entry in
-   `officialPrices`.
-2. Edit the entry's `Input`, `Output` and `CacheHit` to the new values.
-3. If the change is announced ahead of time, set `EffectiveFrom` on the entry.
-4. Confirm `pricing.LatestRate` now returns the new card.
-5. Run `make test` and `make price-check`.

benchmarks/realrepo/snapshot.sh

@@ -1,52 +0,0 @@
-#!/usr/bin/env bash
-# Builds every task's workdir/ from one pinned commit of this repository plus
-# the fixture-authored files in base/ and overlay/<task-id>/. With --check it
-# rebuilds into a scratch directory and fails if any committed workdir differs.
-set -euo pipefail
-
-PIN=42636ddcb425b7af07abd88397d02c1cfe3adcf5
-PATHS=(
-	internal/contract/pricing
-	internal/contract/ablation
-	internal/contract/agentgraph
-	internal/base/retrieval
-	internal/base/rulelist
-	internal/base/tokencount
-	internal/base/neterr
-	internal/base/nilutil
-)
-
-here="$(cd "$(dirname "$0")" && pwd)"
-repo="$(git -C "$here" rev-parse --show-toplevel)"
-
-build() {
-	local id="$1" dest="$2"
-	rm -rf "$dest"
-	mkdir -p "$dest"
-	git -C "$repo" archive "$PIN" -- "${PATHS[@]}" | tar -x -C "$dest"
-	cp -R "$here/base/." "$dest/"
-	if [ -d "$here/overlay/$id" ]; then
-		cp -R "$here/overlay/$id/." "$dest/"
-	fi
-}
-
-check=0
-[ "${1:-}" = "--check" ] && check=1
-
-status=0
-for task in "$here"/tasks/*/; do
-	id="$(basename "$task")"
-	if [ "$check" = 1 ]; then
-		scratch="$(mktemp -d)"
-		build "$id" "$scratch/workdir"
-		if ! diff -r "$scratch/workdir" "$task/workdir" >/dev/null; then
-			echo "$id: workdir/ differs from the pinned snapshot; run $0" >&2
-			diff -rq "$scratch/workdir" "$task/workdir" >&2 || true
-			status=1
-		fi
-		rm -rf "$scratch"
-	else
-		build "$id" "$task/workdir"
-	fi
-done
-exit "$status"

benchmarks/realrepo/tasks/rt-cache-write-rate/solution/README.md

@@ -1,73 +0,0 @@
-# Reasonix kernel snapshot
-
-A trimmed slice of the Reasonix Go kernel: the contracts a benchmark report is
-priced and labelled with, a few leaf utilities, and `benchctl`, a small command
-that prints what those contracts answer.
-
-```bash
-make check                                   # gofmt, vet, test
-go run ./cmd/benchctl rate -model deepseek-flash -currency USD
-go run ./cmd/benchctl cost -provider mimo -model mimo-v2.5 -miss 1000000
-go run ./cmd/benchctl tariff -currency CNY -at 2026-10-12T02:00:00Z
-go run ./cmd/benchctl arm -ablate planner,evidence
-```
-
-## Packages
-
-| Package | Owns |
-| --- | --- |
-| `internal/contract/pricing` | the official price book, cost quotes, the spend ledger |
-| `internal/contract/ablation` | which subsystems a benchmark arm switches off, and the arm's name |
-| `internal/contract/agentgraph` | the vocabulary of one run's execution graph |
-| `internal/base/retrieval` | BM25 ranking over CJK-aware tokens |
-| `internal/base/rulelist` | splitting a one-line permission rule list |
-| `internal/base/tokencount` | a cheap token estimate |
-| `internal/base/neterr` | classifying transport errors |
-| `internal/base/nilutil` | typed-nil detection |
-| `cmd/benchctl` | prints rates, costs, peak schedules and arm names |
-
-## Pricing
-
-A `RateCard` is a price per million tokens in one currency:
-
-| Field | Charges |
-| --- | --- |
-| `CacheHit` | prompt tokens served from the provider's cache |
-| `Input` | prompt tokens that missed the cache, and tokens written to it when `CacheWrite` is zero |
-| `Output` | completion tokens |
-| `CacheWrite` | tokens written to the cache, for a vendor that prices them separately (Anthropic) |
-
-A card without `CacheWrite` keeps the fingerprint it had before the field
-existed, so ledgers stored against it stay attached.
-
-`OriginalCostAmount` turns a card and a `UsageTokens` breakdown into a
-fixed-point `Amount`; `PricingFingerprint` keys a card in the ledger, so a
-stored ledger entry stays attached to the card it was priced with.
-`CurrentRate` and `SupersededRates` answer from `officialRates`, which only
-ever grows: a price change appends a generation.
-
-## Ablation
-
-`ablation.Parse` reads a comma-separated list of modules to switch off, and
-`Set.Arm` names the result (`full` for the control). The switchable modules,
-in the order arm names use:
-
-| Module | Off means |
-| --- | --- |
-| `evidence` | no evidence gate on completion claims |
-| `planner` | no two-model planning turn |
-| `subagent` | no delegation to workers |
-| `retrieval` | no retrieval over the folded transcript |
-| `compaction` | no context folding |
-| `upstream` | a dependency edge orders its endpoints without delivering the answer |
-| `recall-search` | recall can read a given address but cannot search for one |
-
-The fold-index scale is a separate axis (`-fold-index`), not a module.
-
-## Skills
-
-Project skills live under `.reasonix/skills/<name>/SKILL.md`.
-
-| Skill | Use it to |
-| --- | --- |
-| `price-change` | record a vendor's price change in the price book |

benchmarks/realrepo/tasks/rt-cache-write-rate/solution/cmd/benchctl/main.go

@@ -1,119 +0,0 @@
-// Command benchctl prints what the pricing and ablation contracts answer for
-// one model or one benchmark arm, so a reviewer can check a rate or an arm name
-// without writing a test.
-package main
-
-import (
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-
-	"reasonix/internal/contract/ablation"
-	"reasonix/internal/contract/pricing"
-)
-
-var errUsage = errors.New("usage: benchctl rate|cost|tariff|arm [flags]")
-
-func main() {
-	if err := run(os.Args[1:], os.Stdout); err != nil {
-		fmt.Fprintln(os.Stderr, "benchctl:", err)
-		os.Exit(2)
-	}
-}
-
-func run(args []string, out io.Writer) error {
-	if len(args) == 0 {
-		return errUsage
-	}
-	switch args[0] {
-	case "rate":
-		return runRate(args[1:], out)
-	case "cost":
-		return runCost(args[1:], out)
-	case "tariff":
-		return runTariff(args[1:], out)
-	case "arm":
-		return runArm(args[1:], out)
-	default:
-		return fmt.Errorf("%w: unknown subcommand %q", errUsage, args[0])
-	}
-}
-
-func runRate(args []string, out io.Writer) error {
-	fs := flag.NewFlagSet("rate", flag.ContinueOnError)
-	fs.SetOutput(out)
-	provider := fs.String("provider", "deepseek", "vendor")
-	model := fs.String("model", "deepseek-flash", "model id")
-	currency := fs.String("currency", "", "currency; empty reads the vendor's default")
-	if err := fs.Parse(args); err != nil {
-		return err
-	}
-	cur := *currency
-	if cur == "" {
-		cur = pricing.DefaultCurrency(*provider)
-	}
-	card := pricing.CurrentRate(*provider, *model, cur)
-	if card == nil {
-		return fmt.Errorf("no official rate for %s/%s in %s", *provider, *model, cur)
-	}
-	fmt.Fprintf(out, "%s/%s %s: cache-hit %g input %g output %g", *provider, *model, card.Currency, card.CacheHit, card.Input, card.Output)
-	if card.CacheWrite != 0 {
-		fmt.Fprintf(out, " cache-write %g", card.CacheWrite)
-	}
-	fmt.Fprintln(out, " per 1M")
-	if entry, ok := pricing.LookupCatalog(*provider, *model, cur, ""); ok && entry.DocURL != "" {
-		fmt.Fprintf(out, "source: %s\n", entry.DocURL)
-	}
-	fmt.Fprintf(out, "superseded generations: %d\n", len(pricing.SupersededRates(*provider, *model, cur)))
-	return nil
-}
-
-func runCost(args []string, out io.Writer) error {
-	fs := flag.NewFlagSet("cost", flag.ContinueOnError)
-	fs.SetOutput(out)
-	provider := fs.String("provider", "deepseek", "vendor")
-	model := fs.String("model", "deepseek-flash", "model id")
-	currency := fs.String("currency", "", "currency; empty reads the vendor's default")
-	hit := fs.Int("hit", 0, "cached prompt tokens")
-	miss := fs.Int("miss", 0, "uncached prompt tokens")
-	completion := fs.Int("completion", 0, "completion tokens")
-	write := fs.Int("write", 0, "uncached prompt tokens that were written to the cache")
-	if err := fs.Parse(args); err != nil {
-		return err
-	}
-	cur := *currency
-	if cur == "" {
-		cur = pricing.DefaultCurrency(*provider)
-	}
-	card := pricing.CurrentRate(*provider, *model, cur)
-	if card == nil {
-		return fmt.Errorf("no official rate for %s/%s in %s", *provider, *model, cur)
-	}
-	usage := pricing.UsageTokens{CacheHitTokens: *hit, CacheMissTokens: *miss, CompletionTokens: *completion, CacheWriteTokens: *write}
-	amount := pricing.OriginalCostAmount(*card, usage)
-	fmt.Fprintf(out, "%s %s\n", amount, pricing.NormalizeCurrency(card.Currency))
-	return nil
-}
-
-func runArm(args []string, out io.Writer) error {
-	fs := flag.NewFlagSet("arm", flag.ContinueOnError)
-	fs.SetOutput(out)
-	spec := fs.String("ablate", "", "comma-separated modules to switch off: "+ablation.ModuleList())
-	foldIndex := fs.String("fold-index", "", "fold-index scale: default, half, quarter or off")
-	list := fs.Bool("list", false, "list the switchable modules")
-	if err := fs.Parse(args); err != nil {
-		return err
-	}
-	if *list {
-		fmt.Fprintln(out, ablation.ModuleList())
-		return nil
-	}
-	set, err := ablation.ParseArm(*spec, *foldIndex)
-	if err != nil {
-		return err
-	}
-	fmt.Fprintln(out, set.Arm())
-	return nil
-}

benchmarks/realrepo/tasks/rt-cache-write-rate/solution/go.mod

@@ -1,3 +0,0 @@
-module reasonix
-
-go 1.26.0

benchmarks/realrepo/tasks/rt-cache-write-rate/solution/internal/contract/pricing/cache_write_test.go

@@ -1,37 +0,0 @@
-package pricing
-
-import "testing"
-
-func TestCacheWriteRateChargesWrittenTokens(t *testing.T) {
-	card := RateCard{Input: 3, CacheWrite: 3.75, Currency: "USD"}
-	usage := UsageTokens{CacheMissTokens: 1000000, CacheWriteTokens: 400000}
-	if got := OriginalCostAmount(card, usage).String(); got != "3.3" {
-		t.Fatalf("cost = %s, want 3.3", got)
-	}
-	card.CacheWrite = 0
-	if got := OriginalCostAmount(card, usage).String(); got != "3" {
-		t.Fatalf("cost without a cache-write rate = %s, want 3", got)
-	}
-}
-
-func TestCacheWriteSeparatesFingerprintsAndCards(t *testing.T) {
-	base := RateCard{CacheHit: 0.02, Input: 1, Output: 2, Currency: "CNY"}
-	withWrite := base
-	withWrite.CacheWrite = 1.25
-	if PricingFingerprint(base) == PricingFingerprint(withWrite) {
-		t.Fatal("cache-write rate does not reach the fingerprint")
-	}
-	if sameCard(base, withWrite) {
-		t.Fatal("cards differing in CacheWrite compare equal")
-	}
-}
-
-func TestAnthropicPricesCacheWrites(t *testing.T) {
-	got := CurrentRate("anthropic", "claude-sonnet-4-5", "USD")
-	if got == nil || got.CacheWrite != 3.75 {
-		t.Fatalf("claude-sonnet-4-5 = %+v", got)
-	}
-	if OfficialProviderForEndpoint("https://api.anthropic.com/v1/messages") != "anthropic" {
-		t.Fatal("api.anthropic.com is not recognised as Anthropic's endpoint")
-	}
-}