sigit-code 1.5.5__tar.gz → 1.5.6__tar.gz

{sigit_code-1.5.5 → sigit_code-1.5.6}/.agents/AGENTS.md

@@ -26,7 +26,23 @@ from the name alone (e.g. `feature/tool-permission-system`, `fix/glob-mtime-sort
 a task, ticket, or session id (not `feature/task-q003hm`).
 
 **IMPORTANT — pull request target:** Always open pull requests against the `development` branch,
-never `main`. `main` is release-only; `development` is where day-to-day work integrates.
+never `main`. `main` is release-only; `development` is where day-to-day work integrates, and the
+release merge (see the `sigit-code-release` skill) is the one thing that ever puts commits on
+`main`.
+
+This rule needs help to hold, because the repository's default branch is `main`: both
+`gh pr create` and the GitHub web form pre-select it, so a PR lands on the wrong base unless the
+base is passed explicitly. Pass it every time, and check that it took:
+
+```sh
+gh pr create --base development --head <branch>
+gh pr view <number> --json baseRefName
+```
+
+Retargeting a PR that was opened against `main` costs nothing before it merges:
+`gh pr edit <number> --base development`. After it merges it costs real work — the change sits on
+`main` while `development`, which the next release is cut from, does not have it, and someone has
+to carry it back by hand. PR #65 went in that way.
 
 **IMPORTANT — branch off `development`:** Start every working branch from the latest
 `origin/development`. Exception: when new work *depends on* a feature branch that has not merged
@@ -182,10 +198,11 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   `tests/mcp_stdio.rs`, driven by the test-only `src/bin/mcp_stdio_stub.rs` helper binary
   (excluded from the published crate via `exclude` in `Cargo.toml`). The baked-in official
   server is *also* listed in the public MCP Registry as `si.sigit/sigit` — a **remote**
-  Streamable-HTTP listing (`server.json` at the repo root, published by
-  `release-mcp-registry.yml`). Because it's a remote server, the registry's URL-match rule
-  forces a domain namespace (`si.sigit` ↔ `sigit.si`) verified by a DNS TXT record, not the
-  GitHub-OIDC scheme `smbcloud-cli` uses for its package listing.
+  Streamable-HTTP listing owned by the [`getsigit/si`](https://github.com/getsigit/si) repo
+  (`server.json` at its root, published by its `release-mcp-registry.yml`), not this one. Because
+  it's a remote server, the registry's URL-match rule forces a domain namespace (`si.sigit` ↔
+  `sigit.si`) verified by a DNS TXT record, not the GitHub-OIDC scheme `smbcloud-cli` uses for its
+  package listing.
 - **`src/permissions.rs`** — tool permission policy. Every tool call passes through
   `decision_for` before executing: read-only tools always run; mutating tools (and all
   `mcp__*`/unknown tools) are governed by, in order: per-session plan mode (`/plan` — deny all

{sigit_code-1.5.5 → sigit_code-1.5.6}/.agents/skills/sigit-code-release/SKILL.md

@@ -29,8 +29,13 @@ Use this skill when preparing a release for this repository.
 - Add or update the top changelog entry in `CHANGELOG.md` for the release being cut.
 - Do not treat `npm/sigit/package.json` `0.0.0-dev` as a bug by default. The npm release workflow rewrites it at publish time using `npm/scripts/render-main-package.cjs` and the release tag.
 - Do not add a hardcoded version to `pypi/pyproject.toml` for normal releases. PyPI uses `maturin` with `dynamic = ["version"]` and derives the published package version from `Cargo.toml`.
-- Release workflows are tag-driven. `release-github.yml`, `release-npm.yml`, `release-pypi.yml`, `release-crates.yml`, and `release-homebrew.yml` all derive `RELEASE_VERSION` from a `v*.*.*` tag or a manually supplied tag input.
+- Release workflows are tag-driven. `release-github.yml`, `release-npm.yml`, `release-pypi.yml`, `release-crates.yml`, `release-homebrew.yml`, `release-nuget.yml`, and `release-mcp-registry.yml` all derive `RELEASE_VERSION` from a `v*.*.*` tag or a manually supplied tag input.
 - The crate is published to crates.io (`release-crates.yml`) and the Homebrew tap is updated (`release-homebrew.yml`) as part of the tag-driven flow. Per the siGit release flow, Homebrew is auto-triggered — do not dispatch it manually.
+- `release-github.yml` builds the binaries, attaches them (plus a `.deb`/`.rpm` per Linux target built with nfpm from `packaging/nfpm.yaml`) to the GitHub release, then dispatches `release-homebrew`, `release-scoop`, `release-winget`, and `release-aur`. A dispatch failure in any one of those four is logged as a warning, not a hard failure — an unconfigured channel doesn't block the rest of the release. `release-nuget.yml` and `release-mcp-registry.yml`, by contrast, are tag-triggered directly like the other language-registry workflows, not dispatched from `release-github.yml`.
+- Every release asset carries a `.sha256` sidecar (not just the macOS Homebrew tarball). Scoop, winget, and the AUR PKGBUILD each consume the raw binaries plus their sidecar checksum, rather than the tarball.
+- npm and NuGet publish via OIDC trusted publishing — neither has a stored token in the repo. On npm this is configured per package (each `@getsigit/*` name has a trusted publisher pointing at `release-npm.yml`), so a new package needs the same setup before its first publish will work. OIDC requires npm >= 11.5.1 and Node >= 22.14.0.
+- The NuGet package (`SiGit.Code`, `dotnet tool install --global SiGit.Code`) bundles all six platform binaries under `native/<os>-<arch>/` behind a managed shim, rather than shipping one package per platform like npm/PyPI. Watch the nuget.org 250 MB package-size limit if it ever grows.
+- The baked-in official MCP server is separately listed in the public MCP Registry as `si.sigit/sigit` (`release-mcp-registry.yml`, driven by `server.json` at the repo root). It's a remote Streamable-HTTP listing, so it's verified by a DNS TXT record on the `sigit.si` domain rather than the GitHub-OIDC scheme used for package listings.
 
 ## Git release flow
 
@@ -42,6 +47,8 @@ Releases are cut from `development` and shipped on `main`. The published tags (`
 4. Merge `development` into `main` (commit message: `Merge development into main for v<version> release`).
 5. Tag `v<version>` on that `main` merge commit, then push `main` and the tag.
 
+Step 4 is the only way commits are meant to reach `main`. A feature or fix PR targeting `main` breaks that: it puts work on the release branch that `development` does not have, so the next release is cut without it. Such PRs belong on `development` (see the pull request target rule in `AGENTS.md`).
+
 Pushing the `v*.*.*` tag is what fires every release workflow, so create and push it only after the merge into `main` has landed. Do not commit, tag, or push until the user explicitly asks — confirm the version and that they want the release to go out first.
 
 ## Typical files to inspect
@@ -54,7 +61,10 @@ Pushing the `v*.*.*` tag is what fires every release workflow, so create and pus
 - `npm/scripts/render-main-package.cjs`
 - `npm/`
 - `pypi/`
-- `.github/workflows/` (`release-github.yml`, `release-npm.yml`, `release-pypi.yml`, `release-crates.yml`, `release-homebrew.yml`)
+- `nuget/sigit/` (bundled-binary `.NET` tool packaging)
+- `packaging/` (`nfpm.yaml` for `.deb`/`.rpm`, plus `aur/` and `winget/` templates)
+- `server.json` (MCP Registry listing)
+- `.github/workflows/` (`release-github.yml`, `release-npm.yml`, `release-pypi.yml`, `release-crates.yml`, `release-homebrew.yml`, `release-scoop.yml`, `release-winget.yml`, `release-aur.yml`, `release-nuget.yml`, `release-mcp-registry.yml`)
 
 ## Release checklist
 
@@ -67,5 +77,6 @@ Pushing the `v*.*.*` tag is what fires every release workflow, so create and pus
 - Git flow followed: bump committed on `release/v<version>`, merged back to `development`, then `development` merged into `main`, with `v<version>` tagged on the `main` merge commit.
 - Release notes or changelog entries match the actual changes.
 - CI-equivalent local checks pass for the relevant platform or target.
-- Package names, install commands, and branding stay consistent.
-- Any known release limitations are called out explicitly.
+- Package names, install commands, and branding stay consistent across npm, PyPI, crates.io, Homebrew, NuGet, Scoop, winget, AUR, and the `.deb`/`.rpm` packages.
+- Every release asset (including the new `.deb`/`.rpm`/raw binaries consumed by Scoop, winget, and AUR) has a matching `.sha256` sidecar.
+- Any known release limitations are called out explicitly, including a dispatch failure in `release-scoop`/`release-winget`/`release-aur` (non-fatal — logged as a warning by `release-github.yml`) versus a hard failure in a directly tag-triggered workflow like `release-nuget` or `release-mcp-registry`.

{sigit_code-1.5.5 → sigit_code-1.5.6}/.claude/skills/sigit-code-release/SKILL.md

@@ -29,8 +29,13 @@ Use this skill when preparing a release for this repository.
 - Add or update the top changelog entry in `CHANGELOG.md` for the release being cut.
 - Do not treat `npm/sigit/package.json` `0.0.0-dev` as a bug by default. The npm release workflow rewrites it at publish time using `npm/scripts/render-main-package.cjs` and the release tag.
 - Do not add a hardcoded version to `pypi/pyproject.toml` for normal releases. PyPI uses `maturin` with `dynamic = ["version"]` and derives the published package version from `Cargo.toml`.
-- Release workflows are tag-driven. `release-github.yml`, `release-npm.yml`, `release-pypi.yml`, `release-crates.yml`, and `release-homebrew.yml` all derive `RELEASE_VERSION` from a `v*.*.*` tag or a manually supplied tag input.
+- Release workflows are tag-driven. `release-github.yml`, `release-npm.yml`, `release-pypi.yml`, `release-crates.yml`, `release-homebrew.yml`, `release-nuget.yml`, and `release-mcp-registry.yml` all derive `RELEASE_VERSION` from a `v*.*.*` tag or a manually supplied tag input.
 - The crate is published to crates.io (`release-crates.yml`) and the Homebrew tap is updated (`release-homebrew.yml`) as part of the tag-driven flow. Per the siGit release flow, Homebrew is auto-triggered — do not dispatch it manually.
+- `release-github.yml` builds the binaries, attaches them (plus a `.deb`/`.rpm` per Linux target built with nfpm from `packaging/nfpm.yaml`) to the GitHub release, then dispatches `release-homebrew`, `release-scoop`, `release-winget`, and `release-aur`. A dispatch failure in any one of those four is logged as a warning, not a hard failure — an unconfigured channel doesn't block the rest of the release. `release-nuget.yml` and `release-mcp-registry.yml`, by contrast, are tag-triggered directly like the other language-registry workflows, not dispatched from `release-github.yml`.
+- Every release asset carries a `.sha256` sidecar (not just the macOS Homebrew tarball). Scoop, winget, and the AUR PKGBUILD each consume the raw binaries plus their sidecar checksum, rather than the tarball.
+- npm and NuGet publish via OIDC trusted publishing — neither has a stored token in the repo. On npm this is configured per package (each `@getsigit/*` name has a trusted publisher pointing at `release-npm.yml`), so a new package needs the same setup before its first publish will work. OIDC requires npm >= 11.5.1 and Node >= 22.14.0.
+- The NuGet package (`SiGit.Code`, `dotnet tool install --global SiGit.Code`) bundles all six platform binaries under `native/<os>-<arch>/` behind a managed shim, rather than shipping one package per platform like npm/PyPI. Watch the nuget.org 250 MB package-size limit if it ever grows.
+- The baked-in official MCP server is separately listed in the public MCP Registry as `si.sigit/sigit` (`release-mcp-registry.yml`, driven by `server.json` at the repo root). It's a remote Streamable-HTTP listing, so it's verified by a DNS TXT record on the `sigit.si` domain rather than the GitHub-OIDC scheme used for package listings.
 
 ## Git release flow
 
@@ -42,6 +47,8 @@ Releases are cut from `development` and shipped on `main`. The published tags (`
 4. Merge `development` into `main` (commit message: `Merge development into main for v<version> release`).
 5. Tag `v<version>` on that `main` merge commit, then push `main` and the tag.
 
+Step 4 is the only way commits are meant to reach `main`. A feature or fix PR targeting `main` breaks that: it puts work on the release branch that `development` does not have, so the next release is cut without it. Such PRs belong on `development` (see the pull request target rule in `AGENTS.md`).
+
 Pushing the `v*.*.*` tag is what fires every release workflow, so create and push it only after the merge into `main` has landed. Do not commit, tag, or push until the user explicitly asks — confirm the version and that they want the release to go out first.
 
 ## Typical files to inspect
@@ -54,7 +61,10 @@ Pushing the `v*.*.*` tag is what fires every release workflow, so create and pus
 - `npm/scripts/render-main-package.cjs`
 - `npm/`
 - `pypi/`
-- `.github/workflows/` (`release-github.yml`, `release-npm.yml`, `release-pypi.yml`, `release-crates.yml`, `release-homebrew.yml`)
+- `nuget/sigit/` (bundled-binary `.NET` tool packaging)
+- `packaging/` (`nfpm.yaml` for `.deb`/`.rpm`, plus `aur/` and `winget/` templates)
+- `server.json` (MCP Registry listing)
+- `.github/workflows/` (`release-github.yml`, `release-npm.yml`, `release-pypi.yml`, `release-crates.yml`, `release-homebrew.yml`, `release-scoop.yml`, `release-winget.yml`, `release-aur.yml`, `release-nuget.yml`, `release-mcp-registry.yml`)
 
 ## Release checklist
 
@@ -67,5 +77,6 @@ Pushing the `v*.*.*` tag is what fires every release workflow, so create and pus
 - Git flow followed: bump committed on `release/v<version>`, merged back to `development`, then `development` merged into `main`, with `v<version>` tagged on the `main` merge commit.
 - Release notes or changelog entries match the actual changes.
 - CI-equivalent local checks pass for the relevant platform or target.
-- Package names, install commands, and branding stay consistent.
-- Any known release limitations are called out explicitly.
+- Package names, install commands, and branding stay consistent across npm, PyPI, crates.io, Homebrew, NuGet, Scoop, winget, AUR, and the `.deb`/`.rpm` packages.
+- Every release asset (including the new `.deb`/`.rpm`/raw binaries consumed by Scoop, winget, and AUR) has a matching `.sha256` sidecar.
+- Any known release limitations are called out explicitly, including a dispatch failure in `release-scoop`/`release-winget`/`release-aur` (non-fatal — logged as a warning by `release-github.yml`) versus a hard failure in a directly tag-triggered workflow like `release-nuget` or `release-mcp-registry`.

{sigit_code-1.5.5 → sigit_code-1.5.6}/AGENTS.md

@@ -26,7 +26,23 @@ from the name alone (e.g. `feature/tool-permission-system`, `fix/glob-mtime-sort
 a task, ticket, or session id (not `feature/task-q003hm`).
 
 **IMPORTANT — pull request target:** Always open pull requests against the `development` branch,
-never `main`. `main` is release-only; `development` is where day-to-day work integrates.
+never `main`. `main` is release-only; `development` is where day-to-day work integrates, and the
+release merge (see the `sigit-code-release` skill) is the one thing that ever puts commits on
+`main`.
+
+This rule needs help to hold, because the repository's default branch is `main`: both
+`gh pr create` and the GitHub web form pre-select it, so a PR lands on the wrong base unless the
+base is passed explicitly. Pass it every time, and check that it took:
+
+```sh
+gh pr create --base development --head <branch>
+gh pr view <number> --json baseRefName
+```
+
+Retargeting a PR that was opened against `main` costs nothing before it merges:
+`gh pr edit <number> --base development`. After it merges it costs real work — the change sits on
+`main` while `development`, which the next release is cut from, does not have it, and someone has
+to carry it back by hand. PR #65 went in that way.
 
 **IMPORTANT — branch off `development`:** Start every working branch from the latest
 `origin/development`. Exception: when new work *depends on* a feature branch that has not merged
@@ -182,10 +198,11 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   `tests/mcp_stdio.rs`, driven by the test-only `src/bin/mcp_stdio_stub.rs` helper binary
   (excluded from the published crate via `exclude` in `Cargo.toml`). The baked-in official
   server is *also* listed in the public MCP Registry as `si.sigit/sigit` — a **remote**
-  Streamable-HTTP listing (`server.json` at the repo root, published by
-  `release-mcp-registry.yml`). Because it's a remote server, the registry's URL-match rule
-  forces a domain namespace (`si.sigit` ↔ `sigit.si`) verified by a DNS TXT record, not the
-  GitHub-OIDC scheme `smbcloud-cli` uses for its package listing.
+  Streamable-HTTP listing owned by the [`getsigit/si`](https://github.com/getsigit/si) repo
+  (`server.json` at its root, published by its `release-mcp-registry.yml`), not this one. Because
+  it's a remote server, the registry's URL-match rule forces a domain namespace (`si.sigit` ↔
+  `sigit.si`) verified by a DNS TXT record, not the GitHub-OIDC scheme `smbcloud-cli` uses for its
+  package listing.
 - **`src/permissions.rs`** — tool permission policy. Every tool call passes through
   `decision_for` before executing: read-only tools always run; mutating tools (and all
   `mcp__*`/unknown tools) are governed by, in order: per-session plan mode (`/plan` — deny all

{sigit_code-1.5.5 → sigit_code-1.5.6}/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 1.5.6
+
+### What changed
+
+- **Switching models mid-conversation no longer restarts it.** Both switching
+  to a local GGUF model and picking a different cloud tier now carry the live
+  conversation history across, repairing any half-finished tool call so
+  strict OpenAI-compatible endpoints don't reject the session
+- **Long-running tools now show progress in ACP clients.** Synchronous tools
+  (shell commands, file operations, `read_website`, ...) run on a blocking
+  thread pool instead of the ACP connection's own task, so a slow command's
+  `in_progress` update reaches the client — and Zed's spinner — while the
+  command is still running instead of arriving with the result
+- **Text from consecutive tool rounds no longer runs together.** ACP and
+  headless clients concatenate consecutive message chunks, so a reply that
+  continued after a tool call used to glue onto the previous round's last
+  sentence with no space. A blank line now opens the next round's text
+- **New onde-cloud model tiers.** The model picker (`/models` in the TUI, the
+  config panel in editors) now offers five additional siGit Code Cloud tiers —
+  `flux`, `apex`, `aura`, `orbit`, and `nova` — alongside the existing Fast,
+  Balanced, Large, Mini, Air, Pro, and KKK options. The tier list mirrors
+  onde-cloud's router catalogue, so all three sides (the picker, the router,
+  and the cloud catalogue) have to be updated together when a tier is added
+- **MCP Registry listing moved to `getsigit/si`.** The `server.json` manifest
+  and its `release-mcp-registry.yml` publish workflow now live in the
+  [`getsigit/si`](https://github.com/getsigit/si) repo alongside the si CLI's
+  other code, since the registry entry describes the si platform rather than
+  the coding agent
+
 ## 1.5.5
 
 A distribution release. siGit Code itself is unchanged. What moved is how it

{sigit_code-1.5.5 → sigit_code-1.5.6}/CLAUDE.md

@@ -26,7 +26,23 @@ from the name alone (e.g. `feature/tool-permission-system`, `fix/glob-mtime-sort
 a task, ticket, or session id (not `feature/task-q003hm`).
 
 **IMPORTANT — pull request target:** Always open pull requests against the `development` branch,
-never `main`. `main` is release-only; `development` is where day-to-day work integrates.
+never `main`. `main` is release-only; `development` is where day-to-day work integrates, and the
+release merge (see the `sigit-code-release` skill) is the one thing that ever puts commits on
+`main`.
+
+This rule needs help to hold, because the repository's default branch is `main`: both
+`gh pr create` and the GitHub web form pre-select it, so a PR lands on the wrong base unless the
+base is passed explicitly. Pass it every time, and check that it took:
+
+```sh
+gh pr create --base development --head <branch>
+gh pr view <number> --json baseRefName
+```
+
+Retargeting a PR that was opened against `main` costs nothing before it merges:
+`gh pr edit <number> --base development`. After it merges it costs real work — the change sits on
+`main` while `development`, which the next release is cut from, does not have it, and someone has
+to carry it back by hand. PR #65 went in that way.
 
 **IMPORTANT — branch off `development`:** Start every working branch from the latest
 `origin/development`. Exception: when new work *depends on* a feature branch that has not merged
@@ -182,10 +198,11 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   `tests/mcp_stdio.rs`, driven by the test-only `src/bin/mcp_stdio_stub.rs` helper binary
   (excluded from the published crate via `exclude` in `Cargo.toml`). The baked-in official
   server is *also* listed in the public MCP Registry as `si.sigit/sigit` — a **remote**
-  Streamable-HTTP listing (`server.json` at the repo root, published by
-  `release-mcp-registry.yml`). Because it's a remote server, the registry's URL-match rule
-  forces a domain namespace (`si.sigit` ↔ `sigit.si`) verified by a DNS TXT record, not the
-  GitHub-OIDC scheme `smbcloud-cli` uses for its package listing.
+  Streamable-HTTP listing owned by the [`getsigit/si`](https://github.com/getsigit/si) repo
+  (`server.json` at its root, published by its `release-mcp-registry.yml`), not this one. Because
+  it's a remote server, the registry's URL-match rule forces a domain namespace (`si.sigit` ↔
+  `sigit.si`) verified by a DNS TXT record, not the GitHub-OIDC scheme `smbcloud-cli` uses for its
+  package listing.
 - **`src/permissions.rs`** — tool permission policy. Every tool call passes through
   `decision_for` before executing: read-only tools always run; mutating tools (and all
   `mcp__*`/unknown tools) are governed by, in order: per-session plan mode (`/plan` — deny all

{sigit_code-1.5.5 → sigit_code-1.5.6}/Cargo.lock

@@ -5778,7 +5778,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sigit"
-version = "1.5.5"
+version = "1.5.6"
 dependencies = [
  "agent-client-protocol",
  "anyhow",

{sigit_code-1.5.5 → sigit_code-1.5.6}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sigit"
-version = "1.5.5"
+version = "1.5.6"
 edition = "2024"
 description = "siGit Code — ACP-compatible AI coding agent. Sí, git."
 documentation = "https://github.com/getsigit/sigit"

{sigit_code-1.5.5 → sigit_code-1.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sigit-code
-Version: 1.5.5
+Version: 1.5.6
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{sigit_code-1.5.5 → sigit_code-1.5.6}/docs/mcp.md

@@ -63,6 +63,8 @@ The server is published to the
 [official MCP Registry](https://registry.modelcontextprotocol.io) as
 **`si.sigit/sigit`**, a remote Streamable-HTTP listing, so registry-aware
 clients can add it in one click. The registry only stores metadata; the
-`server.json` and publish workflow live in this repo, and namespace ownership is
-proven by a DNS TXT record on `sigit.si`. The internal setup and release runbook
-live with the server (private `sigit-si` repo).
+`server.json` and publish workflow live in the
+[`getsigit/si`](https://github.com/getsigit/si) repo (the `si` CLI, also an
+MCP client of this server), and namespace ownership is proven by a DNS TXT
+record on `sigit.si`. The internal setup and release runbook live with the
+server (private `sigit-si` repo).

{sigit_code-1.5.5 → sigit_code-1.5.6}/src/backend.rs

@@ -880,6 +880,89 @@ struct StreamFunctionDelta {
     arguments: Option<String>,
 }
 
+// ── Carrying a conversation across a model switch ────────────────────────────
+
+/// The part of a history snapshot that survives a model switch: every
+/// non-system message, with half-finished tool plumbing repaired.
+///
+/// System messages are dropped because the backend being switched *to* seeds
+/// its own — a different model's prompt, or a freshly pushed session-context
+/// message. A switch can land mid-turn, after the assistant asked for a tool
+/// but before the results came back; a tool call with no matching result (or a
+/// result with no matching call) makes strict OpenAI-compatible endpoints
+/// reject every later request in the session, so those halves are stripped
+/// instead of carried.
+pub fn carryover_history(snapshot: Vec<serde_json::Value>) -> Vec<serde_json::Value> {
+    let answered: std::collections::HashSet<String> = snapshot
+        .iter()
+        .filter(|message| message["role"] == "tool")
+        .filter_map(|message| message["tool_call_id"].as_str().map(str::to_string))
+        .collect();
+
+    let mut carried: Vec<serde_json::Value> = Vec::with_capacity(snapshot.len());
+    let mut called: std::collections::HashSet<String> = std::collections::HashSet::new();
+
+    for mut message in snapshot {
+        match message["role"].as_str().unwrap_or_default() {
+            "system" => continue,
+            "assistant" => {
+                if let Some(calls) = message["tool_calls"].as_array() {
+                    let kept: Vec<serde_json::Value> = calls
+                        .iter()
+                        .filter(|call| call["id"].as_str().is_some_and(|id| answered.contains(id)))
+                        .cloned()
+                        .collect();
+                    if kept.is_empty() {
+                        // Only unanswered requests: keep whatever text came
+                        // with them, drop the message if there was none.
+                        if let Some(object) = message.as_object_mut() {
+                            object.remove("tool_calls");
+                        }
+                        if message["content"].as_str().unwrap_or_default().is_empty() {
+                            continue;
+                        }
+                    } else {
+                        for call in &kept {
+                            called.insert(call["id"].as_str().unwrap_or_default().to_string());
+                        }
+                        message["tool_calls"] = serde_json::Value::Array(kept);
+                    }
+                }
+                carried.push(message);
+            }
+            "tool" => {
+                let answers_a_kept_call = message["tool_call_id"]
+                    .as_str()
+                    .is_some_and(|id| called.contains(id));
+                if answers_a_kept_call {
+                    carried.push(message);
+                }
+            }
+            _ => carried.push(message),
+        }
+    }
+
+    carried
+}
+
+/// Replay `carried` (from [`carryover_history`]) into `backend`, on top of the
+/// system messages `backend` seeded for itself. Used when a model switch
+/// installs a new backend — or reloads the on-device engine, which wipes its
+/// history — so the thread continues under the new model instead of restarting.
+pub async fn adopt_carryover(backend: &dyn InferenceBackend, carried: Vec<serde_json::Value>) {
+    if carried.is_empty() {
+        return;
+    }
+    let mut rebuilt: Vec<serde_json::Value> = backend
+        .history_snapshot()
+        .await
+        .into_iter()
+        .take_while(|message| message["role"] == "system")
+        .collect();
+    rebuilt.extend(carried);
+    backend.restore_history(rebuilt).await;
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -968,6 +1051,125 @@ mod tests {
         assert_eq!(last["content"], "cancelled by the user");
     }
 
+    #[test]
+    fn carryover_drops_system_messages_and_keeps_the_turns() {
+        let snapshot = vec![
+            serde_json::json!({ "role": "system", "content": "old prompt" }),
+            serde_json::json!({ "role": "user", "content": "hello" }),
+            serde_json::json!({ "role": "assistant", "content": "hi" }),
+        ];
+
+        let carried = carryover_history(snapshot);
+
+        assert_eq!(carried.len(), 2);
+        assert_eq!(carried[0]["role"], "user");
+        assert_eq!(carried[1]["content"], "hi");
+    }
+
+    #[test]
+    fn carryover_strips_a_tool_call_that_never_got_a_result() {
+        // Switching mid-turn: the assistant asked for a tool, nothing answered.
+        let snapshot = vec![
+            serde_json::json!({ "role": "user", "content": "read a.rs" }),
+            streamed_assistant_history(
+                "on it",
+                &[ToolCall {
+                    id: "call_1".to_string(),
+                    name: "read_file".to_string(),
+                    arguments: "{}".to_string(),
+                }],
+            ),
+        ];
+
+        let carried = carryover_history(snapshot);
+
+        assert_eq!(carried.len(), 2);
+        assert_eq!(carried[1]["content"], "on it");
+        assert!(
+            carried[1].get("tool_calls").is_none(),
+            "an unanswered tool call must not survive the switch"
+        );
+    }
+
+    #[test]
+    fn carryover_drops_a_textless_unanswered_tool_call_and_its_late_result() {
+        let snapshot = vec![
+            streamed_assistant_history(
+                "",
+                &[ToolCall {
+                    id: "call_1".to_string(),
+                    name: "read_file".to_string(),
+                    arguments: "{}".to_string(),
+                }],
+            ),
+            // An orphan: its assistant message is gone with the line above.
+            serde_json::json!({
+                "role": "tool",
+                "tool_call_id": "call_other",
+                "content": "file contents",
+            }),
+        ];
+
+        assert!(carryover_history(snapshot).is_empty());
+    }
+
+    #[test]
+    fn carryover_keeps_an_answered_tool_call_paired_with_its_result() {
+        let snapshot = vec![
+            streamed_assistant_history(
+                "",
+                &[ToolCall {
+                    id: "call_1".to_string(),
+                    name: "read_file".to_string(),
+                    arguments: "{}".to_string(),
+                }],
+            ),
+            serde_json::json!({
+                "role": "tool",
+                "tool_call_id": "call_1",
+                "content": "file contents",
+            }),
+        ];
+
+        let carried = carryover_history(snapshot);
+
+        assert_eq!(carried.len(), 2);
+        assert_eq!(carried[0]["tool_calls"][0]["id"], "call_1");
+        assert_eq!(carried[1]["tool_call_id"], "call_1");
+    }
+
+    #[tokio::test]
+    async fn adopt_carryover_replays_the_thread_under_the_new_system_prompt() {
+        let new_backend =
+            OpenAiBackend::new("http://localhost", "", "m", Some("new prompt".into()));
+
+        let carried = carryover_history(vec![
+            serde_json::json!({ "role": "system", "content": "old prompt" }),
+            serde_json::json!({ "role": "user", "content": "hello" }),
+            serde_json::json!({ "role": "assistant", "content": "hi" }),
+        ]);
+        adopt_carryover(&new_backend, carried).await;
+
+        let history = new_backend.history_snapshot().await;
+        assert_eq!(history.len(), 3);
+        assert_eq!(history[0]["role"], "system");
+        assert_eq!(history[0]["content"], "new prompt");
+        assert_eq!(history[1]["content"], "hello");
+        assert_eq!(history[2]["content"], "hi");
+    }
+
+    #[tokio::test]
+    async fn adopt_carryover_leaves_a_fresh_backend_alone() {
+        let new_backend =
+            OpenAiBackend::new("http://localhost", "", "m", Some("new prompt".into()));
+
+        adopt_carryover(&new_backend, Vec::new()).await;
+
+        let history = new_backend.history_snapshot().await;
+        assert_eq!(history.len(), 1);
+        assert_eq!(history[0]["content"], "new prompt");
+    }
+
     #[test]
     fn estimate_tokens_scales_with_serialized_size() {
         assert_eq!(estimate_tokens(&[]), 0);

{sigit_code-1.5.5 → sigit_code-1.5.6}/src/headless.rs

@@ -228,16 +228,12 @@ async fn run_prompt(
     // sink is passed and only the final message is printed.
     let (sink, mut sink_rx) = tokio::sync::mpsc::unbounded_channel::<String>();
     let sink_opt = if config.quiet { None } else { Some(&sink) };
-    let mut assembled = String::new();
-    let mut sent = String::new();
-    let mut streamed_any = false;
+    let mut reply = crate::StreamedReply::default();
 
     let mut result = drain_to_stdout(
         backend.send_message_with_tools(&config.prompt, &tools, sink_opt),
         &mut sink_rx,
-        &mut assembled,
-        &mut sent,
-        &mut streamed_any,
+        &mut reply,
     )
     .await?;
 
@@ -300,12 +296,14 @@ async fn run_prompt(
             None // last round: force text
         };
 
+        // Whatever this round says starts a new paragraph rather than
+        // continuing the sentence the tool calls interrupted.
+        reply.interrupt();
+
         result = drain_to_stdout(
             backend.send_tool_results(tool_results, next_tools, sink_opt),
             &mut sink_rx,
-            &mut assembled,
-            &mut sent,
-            &mut streamed_any,
+            &mut reply,
         )
         .await?;
     }
@@ -318,7 +316,7 @@ async fn run_prompt(
         if !final_visible.is_empty() {
             let _ = writeln!(stdout, "{final_visible}");
         }
-    } else if streamed_any {
+    } else if reply.streamed_any {
         // The reply is already on stdout; end the line for the shell.
         let _ = writeln!(stdout);
     } else if !final_visible.is_empty() {
@@ -335,9 +333,7 @@ async fn run_prompt(
 async fn drain_to_stdout<F>(
     fut: F,
     sink_rx: &mut tokio::sync::mpsc::UnboundedReceiver<String>,
-    assembled: &mut String,
-    sent: &mut String,
-    streamed_any: &mut bool,
+    reply: &mut crate::StreamedReply,
 ) -> Result<TurnResult, backend::BackendError>
 where
     F: std::future::Future<Output = Result<TurnResult, backend::BackendError>>,
@@ -347,39 +343,23 @@ where
         tokio::select! {
             done = &mut fut => break done,
             Some(piece) = sink_rx.recv() => {
-                emit_visible_chunk(&piece, assembled, sent, streamed_any);
+                emit_visible_chunk(&piece, reply);
             }
         }
     };
     // Flush tokens that landed between the last poll and the future resolving.
     while let Ok(piece) = sink_rx.try_recv() {
-        emit_visible_chunk(&piece, assembled, sent, streamed_any);
+        emit_visible_chunk(&piece, reply);
     }
     result
 }
 
-/// Append a streamed fragment, strip `<think>` reasoning from the running
-/// text, and print only the newly revealed visible suffix. Tracking the
-/// assembled text (not just deltas) keeps think-block stripping correct even
-/// when a tag spans chunk boundaries — same approach as the ACP path.
-fn emit_visible_chunk(
-    piece: &str,
-    assembled: &mut String,
-    sent: &mut String,
-    streamed_any: &mut bool,
-) {
-    assembled.push_str(piece);
-    let (_think, visible) = crate::chat::strip_think_blocks(assembled);
-    match visible.strip_prefix(sent.as_str()) {
-        Some(extra) if !extra.is_empty() => {
-            print!("{extra}");
-            let _ = std::io::stdout().flush();
-            *sent = visible;
-            *streamed_any = true;
-        }
-        // No new visible text, or the visible prefix changed retroactively
-        // (rare, e.g. a late-closing think tag): resync without reprinting.
-        _ => *sent = visible,
+/// Fold a streamed fragment into `reply` and print whatever it newly reveals —
+/// the stdio counterpart of `SiGitAgent::emit_visible_chunk`.
+fn emit_visible_chunk(piece: &str, reply: &mut crate::StreamedReply) {
+    if let Some(extra) = reply.push(piece) {
+        print!("{extra}");
+        let _ = std::io::stdout().flush();
     }
 }