sigit-code 1.5.9__tar.gz → 1.5.10__tar.gz

{sigit_code-1.5.9 → sigit_code-1.5.10}/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 1.5.10
+
+### What changed
+
+- **Xcode's context no longer buries slash commands.** Xcode sends the user's
+  prompt as the last of several text blocks, with project context in the
+  blocks before it, so `/models` and friends sat in the middle of joined text
+  and were handed to the model instead of dispatching locally. Slash-command
+  parsing now searches the prompt's text blocks from the end, so a standalone
+  command in the final user block dispatches no matter what context the client
+  prepends
+- **The nova tier is the default cloud engine.** When local inference is off
+  and no explicit provider override is set, the cloud tier now defaults to
+  `nova` (the `onde-nova` model) instead of the balanced tier, in both the
+  interactive and headless paths
+
+### Fixed
+
+- **Malformed Chinese-model tool calls are handled end-to-end in ACP.** The
+  inline-call recovery that 1.5.9 added for Kimi K3's XTML protocol and GLM's
+  mis-tagged blocks only applied to the interactive and headless surfaces;
+  the ACP path never ran it, so an editor session still surfaced raw protocol
+  text and dropped the calls. Recovery now runs in the ACP prompt loop too,
+  covered by integration tests, and the tool names are checked against the
+  turn's offered tools before anything executes
+- **Suppressed tool-call log spam is gone.** The guard that logs when a
+  structured call is dropped for arriving as forced text fired once per
+  streamed argument fragment — one malformed call could log a warning per
+  chunk. The check now fires once per turn with the count and names of what
+  was dropped, and the non-streaming path reports the same
+- **A history-replay test no longer races on the process cwd.** One ACP test
+  built its expected path from `std::env::current_dir()` while other tests
+  briefly swap that process-global cwd, so on CI it could read a temp
+  directory mid-swap and compare a truncated title against an untruncated
+  expectation. It now uses a fixed path it never needed to derive
+
 ## 1.5.9
 
 ### Fixed

{sigit_code-1.5.9 → sigit_code-1.5.10}/Cargo.lock

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

{sigit_code-1.5.9 → sigit_code-1.5.10}/Cargo.toml

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

{sigit_code-1.5.9 → sigit_code-1.5.10}/PKG-INFO

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

{sigit_code-1.5.9 → sigit_code-1.5.10}/src/backend.rs

@@ -159,12 +159,15 @@ pub trait InferenceBackend: Send + Sync {
         sink: Option<&TokenSink>,
     ) -> Result<TurnResult, BackendError>;
 
-    /// Continue the turn by returning tool results. `tools` may be `None` on the
-    /// final round to force a text answer. `sink` streams that text when set.
+    /// Continue the turn by returning tool results. `allow_tool_calls` controls
+    /// whether `tools` are offered again; the complete catalog remains available
+    /// so a disabled round can recognize and suppress tool-shaped model output.
+    /// `sink` streams assistant text when set.
     async fn send_tool_results(
         &self,
         results: Vec<ToolResult>,
-        tools: Option<&[ToolSpec]>,
+        tools: &[ToolSpec],
+        allow_tool_calls: bool,
         sink: Option<&TokenSink>,
     ) -> Result<TurnResult, BackendError>;
 
@@ -257,7 +260,8 @@ impl InferenceBackend for LocalBackend {
     async fn send_tool_results(
         &self,
         results: Vec<ToolResult>,
-        tools: Option<&[ToolSpec]>,
+        tools: &[ToolSpec],
+        allow_tool_calls: bool,
         sink: Option<&TokenSink>,
     ) -> Result<TurnResult, BackendError> {
         let onde_results: Vec<onde::inference::ToolResult> = results
@@ -268,10 +272,10 @@ impl InferenceBackend for LocalBackend {
             })
             .collect();
 
-        // The final round passes `tools = None` to force a text answer; that's
-        // the only round onde can stream, since no further tool calls are parsed.
+        // A forced-text round is the only round onde can stream, since no
+        // further tool calls are parsed.
         if let Some(sink) = sink
-            && tools.is_none()
+            && !allow_tool_calls
         {
             let rx = self
                 .engine
@@ -281,7 +285,7 @@ impl InferenceBackend for LocalBackend {
             return drain_onde_stream(rx, sink).await;
         }
 
-        let onde_tools = tools.map(to_onde_tools);
+        let onde_tools = allow_tool_calls.then(|| to_onde_tools(tools));
         let result = self
             .engine
             .send_tool_results(onde_results, onde_tools.as_deref())
@@ -485,12 +489,14 @@ impl OpenAiBackend {
             .collect()
     }
 
-    /// POST the current history (plus `tools`) and apply the assistant reply to
-    /// history, returning the neutral turn result. Streams via SSE when `sink`
-    /// is set; otherwise reads a single JSON response.
+    /// POST the current history and apply the assistant reply to history.
+    /// `tools` is always the known catalog, while `allow_tool_calls` determines
+    /// whether it is advertised to the model and whether returned calls may run.
+    /// Streams via SSE when `sink` is set; otherwise reads a single JSON response.
     async fn complete(
         &self,
-        tools: Option<&[ToolSpec]>,
+        tools: &[ToolSpec],
+        allow_tool_calls: bool,
         sink: Option<&TokenSink>,
     ) -> Result<TurnResult, BackendError> {
         let url = format!("{}/chat/completions", self.base_url.trim_end_matches('/'));
@@ -501,9 +507,7 @@ impl OpenAiBackend {
             "messages": *self.history.lock().await,
             "stream": streaming,
         });
-        if let Some(tools) = tools
-            && !tools.is_empty()
-        {
+        if allow_tool_calls && !tools.is_empty() {
             body["tools"] = serde_json::Value::Array(Self::tools_json(tools));
             // OpenAI specifies `auto` as the default when tools are present,
             // but not every OpenAI-compatible gateway implements that default.
@@ -528,13 +532,11 @@ impl OpenAiBackend {
             return Err(describe_api_error(status, &body));
         }
 
-        // The specs are needed downstream to type the arguments of any tool
-        // call the model emitted as text rather than as a structured call.
-        let tools = tools.unwrap_or(&[]);
         if let Some(sink) = sink {
-            self.consume_stream(response, sink, tools).await
+            self.consume_stream(response, sink, tools, allow_tool_calls)
+                .await
         } else {
-            self.consume_json(response, tools).await
+            self.consume_json(response, tools, allow_tool_calls).await
         }
     }
 
@@ -543,6 +545,7 @@ impl OpenAiBackend {
         &self,
         response: reqwest::Response,
         tools: &[ToolSpec],
+        allow_tool_calls: bool,
     ) -> Result<TurnResult, BackendError> {
         let parsed: ChatCompletion = response
             .json()
@@ -556,7 +559,7 @@ impl OpenAiBackend {
             .map(|choice| choice.message)
             .ok_or_else(|| "endpoint returned no choices".to_string())?;
 
-        let text = message.content.clone().unwrap_or_default();
+        let mut text = message.content.clone().unwrap_or_default();
         let tool_calls: Vec<ToolCall> = message
             .tool_calls
             .iter()
@@ -568,6 +571,31 @@ impl OpenAiBackend {
             })
             .collect();
 
+        if !allow_tool_calls {
+            let (cleaned, recovered) = crate::inline_tool_calls::extract(&text, tools);
+            text = cleaned;
+            let suppressed = tool_calls.len() + recovered.len();
+            if suppressed > 0 {
+                let names = tool_calls
+                    .iter()
+                    .map(|call| call.name.as_str())
+                    .chain(recovered.iter().map(|call| call.name.as_str()))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                log::warn!(
+                    "suppressed {suppressed} tool call(s) from a forced-text response: {names}"
+                );
+            }
+            self.history
+                .lock()
+                .await
+                .push(streamed_assistant_history(&text, &[]));
+            return Ok(TurnResult {
+                text,
+                tool_calls: Vec::new(),
+            });
+        }
+
         // Some models write a tool call out as literal `<tool_call>` text
         // instead of using the structured field (see `inline_tool_calls`).
         // Recover it, or the turn ends with the tag rendered as prose and
@@ -617,6 +645,7 @@ impl OpenAiBackend {
         response: reqwest::Response,
         sink: &TokenSink,
         tools: &[ToolSpec],
+        allow_tool_calls: bool,
     ) -> Result<TurnResult, BackendError> {
         use futures::StreamExt;
 
@@ -691,10 +720,12 @@ impl OpenAiBackend {
                                 }
                             }
                             crate::inline_tool_calls::ScanEvent::ToolCall(call) => {
-                                log::warn!(
-                                    "recovered tool call '{}' the model emitted as text instead of a structured call",
-                                    call.name
-                                );
+                                if allow_tool_calls {
+                                    log::warn!(
+                                        "recovered tool call '{}' the model emitted as text instead of a structured call",
+                                        call.name
+                                    );
+                                }
                                 recovered.push(ToolCall {
                                     id: format!("call_recovered_{}", recovered.len()),
                                     name: call.name,
@@ -755,6 +786,19 @@ impl OpenAiBackend {
             .collect();
         tool_calls.extend(recovered);
 
+        if !allow_tool_calls && !tool_calls.is_empty() {
+            let names = tool_calls
+                .iter()
+                .map(|call| call.name.as_str())
+                .collect::<Vec<_>>()
+                .join(", ");
+            log::warn!(
+                "suppressed {} tool call(s) from a forced-text response: {names}",
+                tool_calls.len()
+            );
+            tool_calls.clear();
+        }
+
         // Record the assistant turn so later tool results have context.
         self.history
             .lock()
@@ -813,13 +857,14 @@ impl InferenceBackend for OpenAiBackend {
             .lock()
             .await
             .push(serde_json::json!({ "role": "user", "content": text }));
-        self.complete(Some(tools), sink).await
+        self.complete(tools, true, sink).await
     }
 
     async fn send_tool_results(
         &self,
         results: Vec<ToolResult>,
-        tools: Option<&[ToolSpec]>,
+        tools: &[ToolSpec],
+        allow_tool_calls: bool,
         sink: Option<&TokenSink>,
     ) -> Result<TurnResult, BackendError> {
         {
@@ -832,7 +877,7 @@ impl InferenceBackend for OpenAiBackend {
                 }));
             }
         }
-        self.complete(tools, sink).await
+        self.complete(tools, allow_tool_calls, sink).await
     }
 
     async fn record_cancelled_tool_results(&self, results: Vec<ToolResult>) {
@@ -887,7 +932,7 @@ impl InferenceBackend for OpenAiBackend {
         }));
         *self.history.lock().await = request;
 
-        let summary = match self.complete(None, None).await {
+        let summary = match self.complete(&[], false, None).await {
             Ok(result) => result.text,
             Err(error) => {
                 // Roll back the summarization request; the turn never happened.

{sigit_code-1.5.9 → sigit_code-1.5.10}/src/chat.rs

@@ -3346,12 +3346,8 @@ mod tui {
 
             // on the last round, pass no tools so the model must produce text —
             // that's also the round we can stream on-device.
-            let next_tools = if round < MAX_TOOL_ROUNDS {
-                Some(tools.as_slice())
-            } else {
-                None
-            };
-            let sink = if next_tools.is_none() {
+            let allow_tool_calls = round < MAX_TOOL_ROUNDS;
+            let sink = if !allow_tool_calls {
                 streamed = true;
                 Some(&delta_tx)
             } else {
@@ -3359,7 +3355,7 @@ mod tui {
             };
 
             match backend
-                .send_tool_results(tool_results, next_tools, sink)
+                .send_tool_results(tool_results, &tools, allow_tool_calls, sink)
                 .await
             {
                 Ok(r) => result = r,

{sigit_code-1.5.9 → sigit_code-1.5.10}/src/headless.rs

@@ -170,7 +170,7 @@ pub async fn run(config: HeadlessConfig) -> i32 {
         if settings::local_inference_enabled() {
             None
         } else {
-            provider::cloud_tier_provider("balanced")
+            provider::cloud_tier_provider(provider::DEFAULT_CLOUD_TIER)
         }
     });
     let Some(cfg) = provider_cfg else {
@@ -304,18 +304,14 @@ async fn run_prompt(
             });
         }
 
-        let next_tools = if round < crate::MAX_TOOL_ROUNDS {
-            Some(tools.as_slice())
-        } else {
-            None // last round: force text
-        };
+        let allow_tool_calls = round < crate::MAX_TOOL_ROUNDS;
 
         // 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),
+            backend.send_tool_results(tool_results, &tools, allow_tool_calls, sink_opt),
             &mut sink_rx,
             &mut reply,
         )

{sigit_code-1.5.9 → sigit_code-1.5.10}/src/inline_tool_calls.rs

@@ -83,16 +83,22 @@ pub fn extract(text: &str, tools: &[ToolSpec]) -> (String, Vec<Recovered>) {
 fn parse_xml_block(inner: &str, tools: &[ToolSpec]) -> Option<Recovered> {
     let key_idx = inner.find("<arg_key>");
     let malformed_key_idx = inner.find(XML_OPEN_TAG);
-    let (name, mut rest, malformed_first_key) = match (key_idx, malformed_key_idx) {
-        (Some(key_idx), Some(malformed_key_idx)) if malformed_key_idx < key_idx => (
-            inner[..malformed_key_idx].trim(),
-            &inner[malformed_key_idx..],
-            true,
-        ),
-        (Some(idx), _) => (inner[..idx].trim(), &inner[idx..], false),
-        (None, Some(idx)) => (inner[..idx].trim(), &inner[idx..], true),
-        (None, None) => (inner.trim(), "", false),
-    };
+    let check_status_name = key_idx.and_then(|idx| parse_check_status_preamble(&inner[..idx]));
+    let (name, mut rest, malformed_first_key) =
+        if let (Some(idx), Some(name)) = (key_idx, check_status_name) {
+            (name, &inner[idx..], false)
+        } else {
+            match (key_idx, malformed_key_idx) {
+                (Some(key_idx), Some(malformed_key_idx)) if malformed_key_idx < key_idx => (
+                    inner[..malformed_key_idx].trim(),
+                    &inner[malformed_key_idx..],
+                    true,
+                ),
+                (Some(idx), _) => (inner[..idx].trim(), &inner[idx..], false),
+                (None, Some(idx)) => (inner[..idx].trim(), &inner[idx..], true),
+                (None, None) => (inner.trim(), "", false),
+            }
+        };
     if name.is_empty() || name.contains(['<', '>']) || !offered_tool(tools, name) {
         return None;
     }
@@ -132,6 +138,24 @@ fn parse_xml_block(inner: &str, tools: &[ToolSpec]) -> Option<Recovered> {
     })
 }
 
+/// Some GLM-family responses prefix the real arguments with generation-control
+/// metadata shaped like `tool_name CheckStatus=value</arg_value>`. It is not a
+/// tool argument: accept that exact bounded preamble and discard it, while
+/// leaving every other malformed prefix untouched.
+fn parse_check_status_preamble(prefix: &str) -> Option<&str> {
+    let (name, status) = prefix.trim().split_once(" CheckStatus=")?;
+    let status = status.strip_suffix("</arg_value>")?;
+    if name.is_empty()
+        || status.is_empty()
+        || !status
+            .chars()
+            .all(|character| character.is_ascii_alphanumeric() || matches!(character, '_' | '-'))
+    {
+        return None;
+    }
+    Some(name)
+}
+
 fn parse_k3_tools_block(inner: &str, tools: &[ToolSpec]) -> Option<Vec<Recovered>> {
     let mut calls = Vec::new();
     let mut rest = inner;
@@ -565,6 +589,47 @@ mod tests {
         assert_eq!(args["cwd"], "/tmp");
     }
 
+    #[test]
+    fn recovers_glm_call_with_check_status_before_real_arguments() {
+        let tools = vec![command_output_spec()];
+        let (text, calls) = extract(
+            "polling <tool_call>command_output CheckStatus=true_or_poll_again_with_different_params</arg_value><arg_key>task_id</arg_key><arg_value>1</arg_value></tool_call>",
+            &tools,
+        );
+
+        assert_eq!(text, "polling ");
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].name, "command_output");
+        let args: serde_json::Value = serde_json::from_str(&calls[0].arguments).unwrap();
+        assert_eq!(args["task_id"], 1);
+        assert!(args["task_id"].is_number());
+        assert!(args.get("CheckStatus").is_none());
+    }
+
+    #[test]
+    fn malformed_check_status_preamble_is_left_as_text() {
+        let text = "<tool_call>command_output CheckStatus=keep going</arg_value><arg_key>task_id</arg_key><arg_value>1</arg_value></tool_call>";
+        let (out, calls) = extract(text, &[command_output_spec()]);
+        assert_eq!(out, text);
+        assert!(calls.is_empty());
+    }
+
+    #[test]
+    fn check_status_after_a_real_argument_is_left_as_text() {
+        let text = "<tool_call>command_output<arg_key>task_id</arg_key><arg_value>1</arg_value> CheckStatus=true_or_poll_again_with_different_params</arg_value></tool_call>";
+        let (out, calls) = extract(text, &[command_output_spec()]);
+        assert_eq!(out, text);
+        assert!(calls.is_empty());
+    }
+
+    #[test]
+    fn check_status_for_an_unknown_tool_is_left_as_text() {
+        let text = "<tool_call>not_offered CheckStatus=true_or_poll_again_with_different_params</arg_value><arg_key>task_id</arg_key><arg_value>1</arg_value></tool_call>";
+        let (out, calls) = extract(text, &[command_output_spec()]);
+        assert_eq!(out, text);
+        assert!(calls.is_empty());
+    }
+
     #[test]
     fn unknown_glm_tool_is_left_as_text() {
         let text = "<tool_call>not_offered<tool_call>command</arg_key><arg_value>pwd</arg_value></tool_call>";
@@ -773,6 +838,35 @@ mod tests {
         assert_eq!(args["command"], "pwd");
     }
 
+    #[test]
+    fn scanner_recovers_check_status_call_split_across_chunks() {
+        let tools = vec![command_output_spec()];
+        let mut scanner = StreamScanner::new(&tools);
+        let mut text = String::new();
+        let mut calls = Vec::new();
+
+        for chunk in [
+            "before <tool_call>command_output CheckStatus=true_or_poll_",
+            "again_with_different_params</arg_",
+            "value><arg_key>task_id</arg_key><arg_value>1</arg_value></tool_",
+            "call> after",
+        ] {
+            for event in scanner.push(chunk) {
+                match event {
+                    ScanEvent::Text(value) => text.push_str(&value),
+                    ScanEvent::ToolCall(call) => calls.push(call),
+                }
+            }
+        }
+        if let Some(rest) = scanner.take_pending() {
+            text.push_str(&rest);
+        }
+
+        assert_eq!(text, "before  after");
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].name, "command_output");
+    }
+
     #[test]
     fn scanner_recovers_kimi_k3_tools_split_across_chunk_boundaries() {
         let tools = vec![run_command_spec()];

{sigit_code-1.5.9 → sigit_code-1.5.10}/src/main.rs

@@ -1733,7 +1733,15 @@ impl SiGitAgent {
             return Ok(PromptResponse::new(StopReason::EndTurn));
         }
 
-        let user_text = match parse_slash(&user_text) {
+        let slash_command = parse_slash_from_prompt_texts(args.prompt.iter().filter_map(|block| {
+            if let ContentBlock::Text(text) = block {
+                Some(text.text.as_str())
+            } else {
+                None
+            }
+        }));
+
+        let user_text = match slash_command {
             // `/init` is not a status command: it substitutes the canned
             // AGENTS.md-generation prompt and runs a normal agent turn, so the
             // exploration and file write go through the ordinary tools and
@@ -2036,11 +2044,7 @@ impl SiGitAgent {
                 });
             }
 
-            let next_tools = if round < MAX_TOOL_ROUNDS && !force_text {
-                Some(tools.as_slice())
-            } else {
-                None // last round: force text
-            };
+            let allow_tool_calls = round < MAX_TOOL_ROUNDS && !force_text;
 
             // Whatever this round says starts a new paragraph rather than
             // continuing the sentence the tool calls interrupted.
@@ -2050,7 +2054,7 @@ impl SiGitAgent {
                 .drain_turn(
                     cx,
                     &session_id,
-                    backend.send_tool_results(tool_results, next_tools, Some(&sink)),
+                    backend.send_tool_results(tool_results, &tools, allow_tool_calls, Some(&sink)),
                     &mut sink_rx,
                     &mut reply,
                 )
@@ -2248,7 +2252,11 @@ impl SiGitAgent {
         if settings::local_inference_enabled() {
             return;
         }
-        if self.switch_to_cloud_tier("balanced").await.is_some() {
+        if self
+            .switch_to_cloud_tier(provider::DEFAULT_CLOUD_TIER)
+            .await
+            .is_some()
+        {
             log::info!("startup: local inference off; routing inference to siGit Code Cloud");
         } else {
             log::warn!(
@@ -3032,6 +3040,15 @@ fn parse_slash(input: &str) -> Option<SlashCommand> {
     })
 }
 
+/// ACP clients may prepend context as separate text blocks before the user's
+/// input. Search from the end so a standalone slash command in the final user
+/// block is still dispatched locally instead of being buried in joined context.
+fn parse_slash_from_prompt_texts<'a>(
+    texts: impl DoubleEndedIterator<Item = &'a str>,
+) -> Option<SlashCommand> {
+    texts.rev().find_map(parse_slash)
+}
+
 /// `on`/`off` (and synonyms) → `Some(bool)`; missing or unrecognized → `None`
 /// (meaning "toggle the current value").
 fn parse_on_off(arg: Option<&str>) -> Option<bool> {
@@ -3645,7 +3662,7 @@ async fn run_interactive(tty: std::fs::File, mut cleanup_tty: std::fs::File) ->
                 let cloud_when_off = if settings::local_inference_enabled() {
                     None
                 } else {
-                    provider::cloud_tier_provider("balanced")
+                    provider::cloud_tier_provider(provider::DEFAULT_CLOUD_TIER)
                 };
 
                 match cloud_when_off {
@@ -4176,7 +4193,19 @@ mod tests {
 
     #[test]
     fn history_replay_redraws_the_conversation_for_the_client() {
-        let changelog_path = std::env::current_dir().unwrap().join("CHANGELOG.md");
+        // A fixed path, not `std::env::current_dir()`: the cwd is process-global
+        // and a handful of other tests (skills/commands/subagents discovery,
+        // the subagent end-to-end test) briefly `set_current_dir` to a temp
+        // directory behind `ENV_TEST_LOCK`. This test asserts on the exact
+        // rendered title, so racing one of them mid-run doesn't just read a
+        // stale value — it can hand back a temp path long enough to trip the
+        // title's truncation, breaking an assertion that has nothing to do
+        // with the cwd. A literal path sidesteps the shared state entirely.
+        let changelog_path = if cfg!(windows) {
+            PathBuf::from(r"C:\repo\CHANGELOG.md")
+        } else {
+            PathBuf::from("/repo/CHANGELOG.md")
+        };
         let changelog_path_text = changelog_path.to_string_lossy().into_owned();
         let arguments = serde_json::json!({ "path": changelog_path_text }).to_string();
         let history = vec![
@@ -4411,6 +4440,20 @@ mod tests {
         assert!(matches!(parse_slash(" /init "), Some(SlashCommand::Init)));
     }
 
+    #[test]
+    fn parse_slash_finds_command_after_client_context_blocks() {
+        let texts = [
+            "<system-reminder>Xcode context</system-reminder>",
+            "Project structure: App/App.swift",
+            "/models",
+        ];
+
+        assert!(matches!(
+            parse_slash_from_prompt_texts(texts.into_iter()),
+            Some(SlashCommand::Models(None))
+        ));
+    }
+
     #[test]
     fn system_prompt_points_issue_and_pr_work_at_the_official_mcp_tools() {
         // The guidance must reference the exact namespaced names the official

{sigit_code-1.5.9 → sigit_code-1.5.10}/src/provider.rs

@@ -43,6 +43,8 @@ pub const CLOUD_TIERS: &[&str] = &[
     "nova",
 ];
 
+pub const DEFAULT_CLOUD_TIER: &str = "nova";
+
 /// Base URL of the siGit Code Cloud inference endpoint. Override with
 /// `SIGIT_CLOUD_URL` (dev: `http://localhost:8090/v1`).
 pub fn cloud_base_url() -> String {
@@ -259,4 +261,10 @@ mod tests {
         assert_eq!(non_empty(Some(" x ".to_string())), Some("x".to_string()));
         assert_eq!(non_empty(None), None);
     }
+
+    #[test]
+    fn maps_default_cloud_tier_to_wire_model_id() {
+        assert_eq!(DEFAULT_CLOUD_TIER, "nova");
+        assert_eq!(tier_to_model(DEFAULT_CLOUD_TIER), "onde-nova");
+    }
 }

{sigit_code-1.5.9 → sigit_code-1.5.10}/src/tools.rs

@@ -939,13 +939,9 @@ async fn run_subagent(backend: &dyn InferenceBackend, prompt: &str, allowed: &[S
         }
 
         // On the last round, offer no tools so the model must produce text.
-        let next_tools = if round < SUBAGENT_MAX_TOOL_ROUNDS {
-            Some(specs.as_slice())
-        } else {
-            None
-        };
+        let allow_tool_calls = round < SUBAGENT_MAX_TOOL_ROUNDS;
         result = match backend
-            .send_tool_results(tool_results, next_tools, None)
+            .send_tool_results(tool_results, &specs, allow_tool_calls, None)
             .await
         {
             Ok(r) => r,

{sigit_code-1.5.9 → sigit_code-1.5.10}/tests/acp_permissions.rs

@@ -943,6 +943,120 @@ fn a_tool_call_emitted_as_text_is_executed_rather_than_rendered() {
     let _ = std::fs::remove_dir_all(&scratch);
 }
 
+/// Once the repetition guard removes tools from a request, a model may still
+/// emit its learned tool syntax. Known calls must be removed from the visible
+/// response without being executed or recorded as orphaned history entries.
+#[test]
+fn forced_text_suppresses_glm_check_status_tool_markup() {
+    let repeated_arguments = json!({"task_id": 1}).to_string();
+    let endpoint = start_fake_endpoint(vec![
+        sse_tool_call("call_1", "command_output", &repeated_arguments),
+        sse_tool_call("call_2", "command_output", &repeated_arguments),
+        sse_tool_call("call_3", "command_output", &repeated_arguments),
+        sse_body(&[
+            json!({"choices": [{"delta": {"content": "Build is still running. <tool_call>command_output CheckStatus=true_or_poll_"}}]}),
+            json!({"choices": [{"delta": {"content": "again_with_different_params</arg_value><arg_key>task_id</arg_key><arg_value>1</arg_value></tool_call>"}}]}),
+            // Also enforce the forced-text boundary for a structured call.
+            json!({"choices": [{"delta": {"tool_calls": [{
+                "index": 0,
+                "id": "call_4",
+                "function": {"name": "command_output", "arguments": "{\"task_id\":999}"},
+            }]}}]}),
+        ]),
+        sse_text("Next turn."),
+    ]);
+
+    let scratch =
+        std::env::temp_dir().join(format!("sigit_acp_forced_text_{}", std::process::id()));
+    let config_dir = scratch.join("config");
+    let cwd = scratch.join("cwd");
+    std::fs::create_dir_all(&config_dir).unwrap();
+    std::fs::create_dir_all(&cwd).unwrap();
+
+    let mut agent = spawn_agent(endpoint.port, &config_dir);
+
+    let id = agent.request(
+        "initialize",
+        json!({"protocolVersion": 1, "clientCapabilities": {}}),
+    );
+    agent.wait_for_response(id);
+
+    let id = agent.request("session/new", json!({"cwd": cwd, "mcpServers": []}));
+    let session_id = agent.wait_for_response(id)["result"]["sessionId"]
+        .as_str()
+        .expect("session id")
+        .to_string();
+
+    let prompt_id = agent.request(
+        "session/prompt",
+        json!({
+            "sessionId": session_id,
+            "prompt": [{"type": "text", "text": "keep polling"}],
+        }),
+    );
+    let (response, rendered) = agent.wait_for_prompt(prompt_id);
+    assert_eq!(response["result"]["stopReason"], "end_turn");
+    assert!(
+        rendered.contains("Build is still running."),
+        "surrounding prose should remain visible: {rendered:?}"
+    );
+    assert!(
+        !rendered.contains("<tool_call>")
+            && !rendered.contains("<arg_key>")
+            && !rendered.contains("CheckStatus"),
+        "forced tool markup reached the client: {rendered:?}"
+    );
+
+    {
+        let requests = endpoint.requests.lock().unwrap();
+        assert_eq!(
+            requests.len(),
+            4,
+            "a forced-text tool call must not start another inference round"
+        );
+        assert!(
+            requests[3].get("tools").is_none(),
+            "the repetition guard must not advertise tools: {:?}",
+            requests[3]
+        );
+    }
+
+    // Start another turn so the prior assistant message is replayed and its
+    // sanitized history shape can be inspected in the recorded request.
+    let next_prompt_id = agent.request(
+        "session/prompt",
+        json!({
+            "sessionId": session_id,
+            "prompt": [{"type": "text", "text": "what happened?"}],
+        }),
+    );
+    agent.wait_for_prompt(next_prompt_id);
+
+    let requests = endpoint.requests.lock().unwrap();
+    let replayed_messages = requests[4]["messages"].as_array().expect("messages");
+    let prior_assistant = replayed_messages
+        .iter()
+        .rev()
+        .find(|message| {
+            message["role"] == "assistant"
+                && message["content"]
+                    .as_str()
+                    .is_some_and(|content| content.contains("Build is still running."))
+        })
+        .expect("sanitized forced-text assistant response");
+    assert!(prior_assistant.get("tool_calls").is_none());
+    assert!(
+        !prior_assistant["content"]
+            .as_str()
+            .expect("assistant content")
+            .contains("<tool_call>")
+    );
+    drop(requests);
+
+    drop(agent);
+    let _ = std::fs::remove_dir_all(&scratch);
+}
+
 /// Kimi K3 may emit tool calls in XTML content blocks even when the endpoint is
 /// OpenAI-compatible. The backend should recover those before ACP sees them,
 /// unwrap visible response text, and hide private thinking text.