Merge pull request #5313 from Hmbown/fix/v096-shell-wait-progress

chore(release): prepare v0.9.6

Author: Hmbown

.github/scripts/release-workflows.test.js

@@ -21,6 +21,14 @@ function valuesForKey(source, key) {
   return [...source.matchAll(expression)].map((match) => match[1]);
 }
 
+function namedStep(source, name) {
+  const marker = `      - name: ${name}\n`;
+  const start = source.indexOf(marker);
+  assert.notEqual(start, -1, `missing workflow step: ${name}`);
+  const next = source.indexOf("\n      - ", start + marker.length);
+  return source.slice(start, next === -1 ? source.length : next);
+}
+
 const ci = read(".github/workflows/ci.yml");
 const nightly = read(".github/workflows/nightly.yml");
 const candidate = read(".github/workflows/release-candidate.yml");
@@ -51,7 +59,7 @@ assert.doesNotMatch(ci, /--test qa_pty\b/, "CI must not name the removed qa_pty
 
 const expectedNightlyTargets = [
   "x86_64-unknown-linux-gnu",
-  "aarch64-unknown-linux-gnu",
+  "aarch64-unknown-linux-musl",
   "x86_64-apple-darwin",
   "aarch64-apple-darwin",
   "x86_64-pc-windows-msvc",
@@ -84,6 +92,21 @@ assert.match(
 );
 assert.match(nightly, /startsWith\(matrix\.target, 'x86_64-'\).*runner\.arch == 'X64'/s);
 assert.match(nightly, /startsWith\(matrix\.target, 'aarch64-'\).*runner\.arch == 'ARM64'/s);
+const nightlyArmMuslSetup = namedStep(nightly, "Install Linux ARM64 musl toolchain");
+assert.match(nightlyArmMuslSetup, /matrix\.target == 'aarch64-unknown-linux-musl'/);
+assert.match(nightlyArmMuslSetup, /apt-get install -y binutils musl-tools/);
+assert.match(nightlyArmMuslSetup, /rustup target add --toolchain stable aarch64-unknown-linux-musl/);
+const nightlyArmStaticSmoke = namedStep(
+  nightly,
+  "Verify static Linux ARM64 binary and launch",
+);
+assert.match(
+  nightlyArmStaticSmoke,
+  /matrix\.target == 'aarch64-unknown-linux-musl' && runner\.arch == 'ARM64'/,
+);
+assert.match(nightlyArmStaticSmoke, /readelf -l "\$\{bin_path\}"/);
+assert.match(nightlyArmStaticSmoke, /grep -Fq 'INTERP'/);
+assert.match(nightlyArmStaticSmoke, /"\$\{bin_path\}" --version/);
 assert.doesNotMatch(nightly, /codewhale-tui/);
 assert.doesNotMatch(nightly, /target\/[^\n]*\/codew(?:\.exe)?/);
 assert.match(nightly, /cp "\$\{bin_path\}" "\$\{dir\}\/\$\{artifact\}"/);
@@ -153,7 +176,7 @@ assert.match(artifacts, /^  workflow_call:/m);
 assert.match(artifacts, /^permissions:\n  contents: read$/m);
 const expectedTargets = [
   "x86_64-unknown-linux-musl",
-  "aarch64-unknown-linux-gnu",
+  "aarch64-unknown-linux-musl",
   "aarch64-linux-android",
   "x86_64-apple-darwin",
   "aarch64-apple-darwin",
@@ -162,6 +185,27 @@ const expectedTargets = [
 ].sort();
 assert.deepEqual([...new Set(valuesForKey(artifacts, "target"))].sort(), expectedTargets);
 
+const releaseMuslBuild = namedStep(artifacts, "Build static Linux binaries (musl)");
+assert.match(releaseMuslBuild, /endsWith\(matrix\.target, '-unknown-linux-musl'\)/);
+assert.match(releaseMuslBuild, /apt-get install -y binutils musl-tools/);
+assert.match(releaseMuslBuild, /rustup target add --toolchain stable \$\{\{ matrix\.target \}\}/);
+assert.match(
+  releaseMuslBuild,
+  /cargo build --profile dist --locked --target \$\{\{ matrix\.target \}\} -p codewhale-cli/,
+);
+const releaseStaticSmoke = namedStep(
+  artifacts,
+  "Verify static Linux binaries and launch on matching native runners",
+);
+assert.match(releaseStaticSmoke, /endsWith\(matrix\.target, '-unknown-linux-musl'\)/);
+assert.match(
+  releaseStaticSmoke,
+  /startsWith\(matrix\.target, 'aarch64-'\) && runner\.arch == 'ARM64'/,
+);
+assert.match(releaseStaticSmoke, /readelf -l "\$\{bin_path\}"/);
+assert.match(releaseStaticSmoke, /grep -Fq 'INTERP'/);
+assert.match(releaseStaticSmoke, /"\$\{bin_path\}" --version/);
+
 const builtAssetNames = [
   ...valuesForKey(artifacts, "cli_artifact"),
   ...valuesForKey(artifacts, "shim_artifact"),

.github/workflows/nightly.yml

@@ -37,7 +37,7 @@ jobs:
             primary_artifact: codewhale-linux-x64
             alias_artifact: codew-linux-x64
           - os: ubuntu-24.04-arm
-            target: aarch64-unknown-linux-gnu
+            target: aarch64-unknown-linux-musl
             platform: linux-arm64
             binary: codewhale
             primary_artifact: codewhale-linux-arm64
@@ -88,15 +88,22 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         with:
           cache-bin: false
-      - name: Install Linux system dependencies
-        if: runner.os == 'Linux'
+      - name: Install Linux GNU system dependencies
+        if: matrix.target == 'x86_64-unknown-linux-gnu'
         run: |
           for i in 1 2 3 4 5; do
             sudo apt-get update && break
             echo "apt-get update failed (attempt $i); retrying in 15s"
             sleep 15
           done
           sudo apt-get install -y libdbus-1-dev pkg-config
+      - name: Install Linux ARM64 musl toolchain
+        if: matrix.target == 'aarch64-unknown-linux-musl'
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y binutils musl-tools
+          rustup target add --toolchain stable aarch64-unknown-linux-musl
       - name: Build
         shell: bash
         # Nightly artifacts are disposable smoke binaries (14-day retention),
@@ -117,6 +124,17 @@ jobs:
           done
           echo "Build failed after 3 attempts" >&2
           exit 1
+      - name: Verify static Linux ARM64 binary and launch
+        if: matrix.target == 'aarch64-unknown-linux-musl' && runner.arch == 'ARM64'
+        shell: bash
+        run: |
+          set -euo pipefail
+          bin_path="target/${{ matrix.target }}/release/${{ matrix.binary }}"
+          if readelf -l "${bin_path}" | grep -Fq 'INTERP'; then
+            echo "Expected a static musl binary, but ${bin_path} has an ELF interpreter" >&2
+            exit 1
+          fi
+          "${bin_path}" --version
       - name: Smoke binary on matching native runners
         if: >-
           (startsWith(matrix.target, 'x86_64-') && runner.arch == 'X64') ||

.github/workflows/release-artifacts.yml

@@ -45,7 +45,7 @@ jobs:
             shim_artifact: codew-linux-x64
             tui_artifact: codewhale-tui-linux-x64
           - os: ubuntu-24.04-arm
-            target: aarch64-unknown-linux-gnu
+            target: aarch64-unknown-linux-musl
             platform: linux-arm64
             cli_binary: codewhale
             shim_binary: codew
@@ -116,23 +116,14 @@ jobs:
       - uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
         with:
           cache-bin: false
-      - name: Install Linux ARM64 system dependencies
-        if: matrix.target == 'aarch64-unknown-linux-gnu'
-        run: |
-          for i in 1 2 3 4 5; do
-            sudo apt-get update && break
-            echo "apt-get update failed (attempt $i); retrying in 15s"
-            sleep 15
-          done
-          sudo apt-get install -y libdbus-1-dev pkg-config
-      - name: Build static Linux x64 binaries (musl)
-        if: matrix.target == 'x86_64-unknown-linux-musl'
+      - name: Build static Linux binaries (musl)
+        if: endsWith(matrix.target, '-unknown-linux-musl')
         shell: bash
         run: |
           sudo apt-get update
-          sudo apt-get install -y musl-tools
-          rustup target add --toolchain stable x86_64-unknown-linux-musl
-          cargo build --profile dist --locked --target x86_64-unknown-linux-musl -p codewhale-cli
+          sudo apt-get install -y binutils musl-tools
+          rustup target add --toolchain stable ${{ matrix.target }}
+          cargo build --profile dist --locked --target ${{ matrix.target }} -p codewhale-cli
       - name: Configure Android NDK linker
         if: matrix.target == 'aarch64-linux-android' && runner.os == 'Linux'
         shell: bash
@@ -180,7 +171,7 @@ jobs:
             echo "BINDGEN_EXTRA_CLANG_ARGS_aarch64_linux_android=--target=aarch64-linux-android24 --sysroot=${ndk}/toolchains/llvm/prebuilt/linux-x86_64/sysroot"
           } >> "${GITHUB_ENV}"
       - name: Build
-        if: matrix.target != 'x86_64-unknown-linux-musl'
+        if: ${{ !endsWith(matrix.target, '-unknown-linux-musl') }}
         shell: bash
         run: cargo build --profile dist --locked --target ${{ matrix.target }} -p codewhale-cli
       - name: Materialize codew command alias
@@ -189,6 +180,23 @@ jobs:
           bin_dir="target/${{ matrix.target }}/dist"
           cp "${bin_dir}/${{ matrix.cli_binary }}" "${bin_dir}/${{ matrix.shim_binary }}"
           cmp "${bin_dir}/${{ matrix.cli_binary }}" "${bin_dir}/${{ matrix.shim_binary }}"
+      - name: Verify static Linux binaries and launch on matching native runners
+        if: >-
+          endsWith(matrix.target, '-unknown-linux-musl') &&
+          ((startsWith(matrix.target, 'x86_64-') && runner.arch == 'X64') ||
+          (startsWith(matrix.target, 'aarch64-') && runner.arch == 'ARM64'))
+        shell: bash
+        run: |
+          set -euo pipefail
+          bin_dir="target/${{ matrix.target }}/dist"
+          for binary in "${{ matrix.cli_binary }}" "${{ matrix.shim_binary }}"; do
+            bin_path="${bin_dir}/${binary}"
+            if readelf -l "${bin_path}" | grep -Fq 'INTERP'; then
+              echo "Expected a static musl binary, but ${bin_path} has an ELF interpreter" >&2
+              exit 1
+            fi
+            "${bin_path}" --version
+          done
       - name: Smoke binaries on matching native runners
         if: >-
           matrix.target != 'aarch64-linux-android' &&

CHANGELOG.md

@@ -35,6 +35,134 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   compatible gateways keep the generic Chat contract. FIM
   (`/v1/fim/completions`) is not wired.
 
+## [0.9.6] - 2026-08-09
+
+Codewhale v0.9.6 is a subtractive release. The runtime stopped supervising the
+model and started getting out of its way: the guards that interrupted live work
+are gone, mode-specific prompt doctrine is gone, compaction was rebuilt on a
+much smaller design, and a truncated provider response can no longer be
+recorded as a finished answer.
+
+Most of these were found by running the v0.9.5 binary against Terminal-Bench
+2.1 beside Pi 0.8.41 on the same model, effort, endpoint, and task digests, and
+then reading the trials Codewhale lost.
+
+### Added
+
+- Mistral AI (la Plateforme) is now a first-class OpenAI-compatible provider
+  route. Select it with `provider = "mistral"`, `CODEWHALE_PROVIDER=mistral`,
+  or `codewhale --provider mistral`. Aliases `mistral-ai`, `mistralai`, and
+  `la-plateforme` resolve to the same route. Authenticate with
+  `MISTRAL_API_KEY` (get one at <https://console.mistral.ai/api-keys>), or
+  via `[providers.mistral].api_key` / `codewhale auth set --provider mistral`.
+  Endpoint defaults to `https://api.mistral.ai/v1`; model defaults to
+  `mistral-code-latest` (Codestral coding model, 256K context; the historical
+  `codestral-latest` slug is accepted as an alias). The current static picker
+  ships `mistral-code-latest`, `mistral-medium-latest`,
+  `mistral-small-latest`, and `mistral-large-latest` with 256K-class windows.
+  Adjustable reasoning is wired end-to-end for `mistral-medium-latest` and
+  `mistral-small-latest`: Codewhale sends `reasoning_effort` (`none` or `high`
+  only — intermediate tiers get HTTP 400 code 3051), parses the polymorphic
+  `content: [{type: thinking, thinking: [{type: text, text: ...}], closed:
+  bool}, {type: text, text: ...}]` shape emitted during reasoning, and
+  replays the thinking trace back into multi-turn history per the
+  [official reasoning guide](https://docs.mistral.ai/studio-api/conversations/reasoning).
+  Deprecated native Magistral IDs remain accepted
+  when configured explicitly, always replay thinking, and never receive the
+  adjustable effort field. Non-reasoning models (`mistral-code-latest`,
+  `mistral-large-latest`) never receive it. Mistral-specific reasoning wire
+  behavior is limited to the documented first-party HTTPS `/v1` hosts; custom
+  compatible gateways keep the generic Chat contract. FIM
+  (`/v1/fim/completions`) is not wired.
+- **Persistent background services for headless exec.** `Bash` accepts
+  `persist: true` (Unix, real `codewhale exec`, explicit
+  `--sandbox danger-full-access`, `background: true` only). The service starts
+  with null stdio in its own process group; a successful exec transfers
+  ownership and emits a release receipt naming the pid. Failure, cancellation,
+  a terminating signal, or engine-channel EOF kills it and exits nonzero.
+  Ordinary background jobs keep their existing kill-on-drop lifetime. Before
+  this, a server the model started and verified died when the exec that
+  started it succeeded, and the external verifier got connection refused.
+- **Static Linux ARM64 binaries.** Release and nightly now build
+  `aarch64-unknown-linux-musl` on the native ARM runner, with a static check
+  (no ELF interpreter) and a launch smoke on the matching runner. The previous
+  GNU build inherited the builder's `GLIBC_2.39` floor and would not start on
+  Ubuntu 22.04 ARM64 and similar images.
+
+### Changed
+
+- **`Bash action="wait"` blocks by default.** It previously computed blocking
+  from a separate `wait` boolean defaulting to false, so
+  `{"action":"wait","task_id":...,"timeout_ms":600000}` returned immediately
+  and ignored the timeout. Pass `wait: false` for a nonblocking snapshot.
+  `task_shell_wait` keeps its documented nonblocking default, including when
+  `wait`/`block` arrive as null.
+- **Compaction rebuilt on the Codex design.** One summary request that is the
+  live conversation plus a final handoff-summary message, so the provider's
+  prefix cache covers everything already sent; a committed summary; and a
+  replacement history of the recent user messages within a fixed token budget.
+  On context-window overflow it drops the oldest history item and retries.
+  Sessions saved under the previous format still restore their committed
+  summary. Manual compaction remains nonblocking and serialized, both
+  lifecycle labels persist for the real lifecycle, and the successor request
+  carries the committed summary.
+- **One prompt for every mode.** Plan, Agent, and Operate previously shipped
+  separate doctrine prompts that were prepended to the constitution, so a mode
+  change rewrote the stable prefix. Modes differ in permissions and available
+  tools, which runtime policy and the live tool catalog already express per
+  turn. Headless hosts get a compact constitution; interactive hosts keep the
+  full base; explicit embedder and base-prompt overrides still win.
+- **Goals are no longer bounded from inside the runtime.** The three-per-turn
+  continuation cap, the auto-pause after three identical verifier gap sets, and
+  the instruction to stop at any unanswered question are gone. `max_steps`,
+  the opt-in `[goal] max_continuations` circuit breaker, and terminal
+  complete/blocked status remain the ways a goal run ends.
+- `todo_write` is documented as an optional progress surface. Its description
+  no longer instructs the model to keep the list live or never batch
+  completions.
+
+### Fixed
+
+- **A truncated response is a failure, not an answer.** The turn loop read
+  usage from the message delta and discarded its stop reason; trials that spent
+  their whole output allowance on reasoning and emitted no answer were recorded
+  `status=completed`, `termination_reason=resolved`. The stop reason is now
+  retained end to end. On an incomplete stop the runtime charges the billed
+  usage, keeps the visible fragment as interrupted rather than as a completed
+  assistant message, closes every opened tool lifecycle without executing the
+  call, and fails the turn with the provider's own reason. The Responses
+  adapter preserves `incomplete_details.reason` instead of flattening it, so an
+  unknown future reason cannot be mistaken for a finished answer.
+- The same rule now covers every remaining direct model consumer: compaction,
+  the `review` and `verify` tools, MCP thread handling, purge, the advisor, the
+  auto-route classifier, the fleet router, both setup drafts, and
+  `codewhale review`.
+- **Step-budget exhaustion is a typed failure.** Reaching `max_steps` before
+  completion is `Failed` / `BudgetExhausted` and cannot release a pending
+  persistent service. A goal continuation injected on the final step no longer
+  relabels an already delivered answer as a step-budget failure.
+- Cancellation arriving after the provider reported terminal usage still
+  charges the turn.
+
+### Removed
+
+- **The no-progress stuck guard.** It fingerprinted steps by tool name and
+  arguments with no result digest, so polling a live background job looked
+  identical every time. It stopped `filter-js-from-html` while the task it was
+  waiting on went on to pass, and stopped `llm-inference-batching-scheduler`
+  and `mcmc-sampling-stan` mid-optimizer and mid-compile.
+- **The read-repeat guard.** It coalesced same-batch duplicate reads onto one
+  execution and, past a threshold, replaced results with a receipt pointing at
+  a prior tool-use id. A model that asks to read a file twice now reads it
+  twice.
+- **Tool-error strategy coaching.** Errors were rewritten to append fallback
+  advice, and a degradation hint fired after two consecutive error steps.
+  Errors now return as the tool produced them.
+
+### Contributors
+
+- Xavier Pestel (@xavierpestel-ai) — Mistral AI provider route (#5295).
+
 ## [0.9.5] - 2026-08-08
 
 Codewhale v0.9.5 consolidates the terminal application into one compiled
@@ -5262,6 +5390,7 @@ overflow report and `/theme` picker edge-wrapping patch in #1814.
 Older releases (v0.8.39 and earlier) are archived in [docs/CHANGELOG_ARCHIVE.md](docs/CHANGELOG_ARCHIVE.md).
 
 [Unreleased]: https://github.com/Hmbown/CodeWhale/compare/v0.9.5...HEAD
+[0.9.6]: https://github.com/Hmbown/CodeWhale/compare/v0.9.5...v0.9.6
 [0.9.5]: https://github.com/Hmbown/CodeWhale/compare/v0.9.4...v0.9.5
 [0.9.4]: https://github.com/Hmbown/CodeWhale/compare/v0.9.3...v0.9.4
 [0.9.3]: https://github.com/Hmbown/CodeWhale/compare/v0.9.2...v0.9.3