sigit-code 1.5.11__tar.gz → 1.5.13__tar.gz

{sigit_code-1.5.11 → sigit_code-1.5.13}/.agents/AGENTS.md

@@ -351,6 +351,14 @@ GitHub release, so `release-github` builds the binaries, attaches the assets, an
 is logged as a warning rather than failing the others, so an unconfigured channel does not block a
 release. Their inputs live in `packaging/`.
 
+The Windows binaries link the MSVC C runtime statically (`+crt-static` in `.cargo/config.toml`).
+winget, Scoop, npm, PyPI and NuGet all ship the bare exe with no installer, so a dynamic build
+that imports `VCRUNTIME140.dll` fails to load on a machine without the VC++ Redistributable
+(`0xC0000135`, which is what failed winget's first validation).
+`packaging/windows/check-static-crt.ps1` runs in CI and in `release-github` and fails the build if
+a Windows exe imports the runtime again. Don't set a `RUSTFLAGS` env var in those workflows: it
+replaces the config rustflags instead of adding to them.
+
 Every release asset now carries a `.sha256` sidecar, not just the macOS Homebrew tarball. Scoop,
 winget, and the AUR PKGBUILD each need one, and they consume the raw binaries rather than the
 tarball. `release-github` also builds a `.deb` and `.rpm` per Linux target with nfpm

sigit_code-1.5.13/.cargo/config.toml

@@ -0,0 +1,7 @@
+# Link the MSVC C runtime statically on Windows. Without this the binary
+# imports VCRUNTIME140.dll and the UCRT api-ms-win-crt-*.dll set, and on a
+# machine without the Visual C++ Redistributable it dies at load time with
+# STATUS_DLL_NOT_FOUND (0xC0000135) before main runs. winget ships sigit as a
+# portable exe, so there is no installer to bring the runtime along.
+[target.'cfg(all(windows, target_env = "msvc"))']
+rustflags = ["-C", "target-feature=+crt-static"]

{sigit_code-1.5.11 → sigit_code-1.5.13}/.github/workflows/ci.yml

@@ -119,3 +119,8 @@ jobs:
 
       - name: Test
         run: cargo test --locked --target ${{ matrix.target }}
+
+      - name: Check Windows binary has no VC++ runtime dependency
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: ./packaging/windows/check-static-crt.ps1 -Path target/${{ matrix.target }}/debug/sigit.exe

{sigit_code-1.5.11 → sigit_code-1.5.13}/.github/workflows/release-github.yml

@@ -96,6 +96,11 @@ jobs:
         shell: bash
         run: cargo build --locked --release --target ${{ matrix.target }}
 
+      - name: Check Windows binary has no VC++ runtime dependency
+        if: contains(matrix.target, 'windows')
+        shell: pwsh
+        run: ./packaging/windows/check-static-crt.ps1 -Path target/${{ matrix.target }}/release/${{ env.PROJECT_NAME }}.exe
+
       - name: Package binary
         shell: bash
         run: |

{sigit_code-1.5.11 → sigit_code-1.5.13}/.gitignore

@@ -1,3 +1,4 @@
 /target
 /.zed
 /.idea
+issues:*

{sigit_code-1.5.11 → sigit_code-1.5.13}/AGENTS.md

@@ -351,6 +351,14 @@ GitHub release, so `release-github` builds the binaries, attaches the assets, an
 is logged as a warning rather than failing the others, so an unconfigured channel does not block a
 release. Their inputs live in `packaging/`.
 
+The Windows binaries link the MSVC C runtime statically (`+crt-static` in `.cargo/config.toml`).
+winget, Scoop, npm, PyPI and NuGet all ship the bare exe with no installer, so a dynamic build
+that imports `VCRUNTIME140.dll` fails to load on a machine without the VC++ Redistributable
+(`0xC0000135`, which is what failed winget's first validation).
+`packaging/windows/check-static-crt.ps1` runs in CI and in `release-github` and fails the build if
+a Windows exe imports the runtime again. Don't set a `RUSTFLAGS` env var in those workflows: it
+replaces the config rustflags instead of adding to them.
+
 Every release asset now carries a `.sha256` sidecar, not just the macOS Homebrew tarball. Scoop,
 winget, and the AUR PKGBUILD each need one, and they consume the raw binaries rather than the
 tarball. `release-github` also builds a `.deb` and `.rpm` per Linux target with nfpm

{sigit_code-1.5.11 → sigit_code-1.5.13}/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 ## Unreleased
 
+## 1.5.13
+
+### Added
+
+- **Three more siGit Code Cloud tiers: `flare`, `zenith` and `prism`.** They
+  show up in `/models` and in the editor's model picker alongside the existing
+  tiers. Selecting one needs a signed-in account, as before.
+
+## 1.5.12
+
+### Fixed
+
+- **The Windows binaries start on machines without the Visual C++
+  Redistributable.** They used to import `VCRUNTIME140.dll` and the UCRT
+  `api-ms-win-crt-*` DLLs, so a clean Windows install refused to load them
+  with `STATUS_DLL_NOT_FOUND` (0xC0000135). That is what failed winget's
+  post-install check. The C runtime is now linked statically, and CI and the
+  release build fail if a Windows exe picks up that dependency again.
+
+- **Watching a slow background command no longer ends the turn early.**
+  Polling `command_output` on the same task id three times tripped the
+  repeated-tool-call guard, which refused the call and dropped tools for the
+  rest of the turn. `command_output` now long-polls — it waits up to
+  `wait_seconds` (default 10, max 30) for the task to exit, then returns
+  everything printed in the meantime — and the repeat guard exempts it, since
+  polling the same task is the whole point of the tool.
+
+- **A turn that ends with no visible text says why.** When the
+  repeated-tool-call guard blocked a call and the forced no-tools round came
+  back empty, sigit sent nothing more — the turn just stopped with no answer
+  and no question. When the last round of a tool-using turn produces no
+  visible text, sigit now sends a short closing message naming the repeated
+  tool and asking you to reply "continue" or redirect.
+
 ## 1.5.11
 
 ### Added

{sigit_code-1.5.11 → sigit_code-1.5.13}/CLAUDE.md

@@ -351,6 +351,14 @@ GitHub release, so `release-github` builds the binaries, attaches the assets, an
 is logged as a warning rather than failing the others, so an unconfigured channel does not block a
 release. Their inputs live in `packaging/`.
 
+The Windows binaries link the MSVC C runtime statically (`+crt-static` in `.cargo/config.toml`).
+winget, Scoop, npm, PyPI and NuGet all ship the bare exe with no installer, so a dynamic build
+that imports `VCRUNTIME140.dll` fails to load on a machine without the VC++ Redistributable
+(`0xC0000135`, which is what failed winget's first validation).
+`packaging/windows/check-static-crt.ps1` runs in CI and in `release-github` and fails the build if
+a Windows exe imports the runtime again. Don't set a `RUSTFLAGS` env var in those workflows: it
+replaces the config rustflags instead of adding to them.
+
 Every release asset now carries a `.sha256` sidecar, not just the macOS Homebrew tarball. Scoop,
 winget, and the AUR PKGBUILD each need one, and they consume the raw binaries rather than the
 tarball. `release-github` also builds a `.deb` and `.rpm` per Linux target with nfpm

{sigit_code-1.5.11 → sigit_code-1.5.13}/Cargo.lock

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

{sigit_code-1.5.11 → sigit_code-1.5.13}/Cargo.toml

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

{sigit_code-1.5.11 → sigit_code-1.5.13}/PKG-INFO

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

sigit_code-1.5.13/packaging/windows/check-static-crt.ps1

@@ -0,0 +1,35 @@
+# Fails if a Windows binary depends on the Visual C++ runtime DLLs.
+#
+# sigit is linked with +crt-static (see .cargo/config.toml) so it runs on a
+# clean Windows install. If RUSTFLAGS overrides that, or a native dependency
+# drags in the DLL runtime, the exe still builds and passes tests on a runner
+# that has the redistributable installed, then fails to load on users'
+# machines. This check catches it before release.
+param(
+    [Parameter(Mandatory = $true)]
+    [string]$Path
+)
+
+$ErrorActionPreference = 'Stop'
+
+$vswhere = Join-Path ${env:ProgramFiles(x86)} 'Microsoft Visual Studio\Installer\vswhere.exe'
+$dumpbin = & $vswhere -latest -products * -find 'VC\Tools\MSVC\*\bin\Hostx64\x64\dumpbin.exe' |
+    Select-Object -First 1
+if (-not $dumpbin) {
+    throw 'dumpbin.exe not found; is the MSVC toolset installed?'
+}
+
+$output = & $dumpbin /nologo /dependents $Path
+if ($LASTEXITCODE -ne 0) {
+    throw "dumpbin failed on $Path"
+}
+$output | Write-Host
+
+$runtime = $output |
+    Where-Object { $_ -match '^\s+(vcruntime|msvcp|concrt|ucrtbase|api-ms-win-crt-)\S*\.dll\s*$' } |
+    ForEach-Object { $_.Trim() }
+if ($runtime) {
+    Write-Host "::error::$Path depends on the Visual C++ runtime: $($runtime -join ', ')"
+    exit 1
+}
+Write-Host "$Path does not depend on the Visual C++ runtime."

{sigit_code-1.5.11 → sigit_code-1.5.13}/packaging/winget/getSigit.siGitCode.installer.yaml.in

@@ -6,6 +6,8 @@ InstallerType: portable
 # assets are sigit-win-<arch>.exe, but the command has to be `sigit`.
 Commands:
   - sigit
+# No VCRedist dependency: the exe links the C runtime statically
+# (.cargo/config.toml), and CI rejects a build that imports it.
 ReleaseDate: "@RELEASE_DATE@"
 Installers:
   - Architecture: x64

{sigit_code-1.5.11 → sigit_code-1.5.13}/src/main.rs

@@ -266,6 +266,21 @@ pub(crate) fn system_prompt_for_model(tool_calling: bool) -> String {
 /// context window, so the cap can afford to be generous
 const MAX_TOOL_ROUNDS: usize = 24;
 
+/// What the user sees when a turn that ran tools ends with no closing text.
+fn silent_stop_message(repeated_tool: Option<&str>, rounds: usize) -> String {
+    match repeated_tool {
+        Some(tool) => format!(
+            "I stopped because I kept making the same `{tool}` call without getting \
+             anywhere, and I had nothing to add without it. Reply \"continue\" to pick \
+             it back up, or tell me what to try instead."
+        ),
+        None => format!(
+            "I stopped after {rounds} tool round(s) without writing a final answer. \
+             Reply \"continue\" to pick it back up, or tell me what to try instead."
+        ),
+    }
+}
+
 /// Separator between two stretches of assistant prose that a tool round split
 /// apart. ACP clients concatenate consecutive agent-message chunks into a
 /// single block, so a plain newline (or nothing at all) leaves the rounds
@@ -2231,6 +2246,11 @@ impl SiGitAgent {
         };
 
         let mut round = 0;
+        // Set when the repetition guard blocked a call; names the tool.
+        let mut stopped_repeating: Option<String> = None;
+        // Visible text already sent before the latest inference round, so the
+        // end of the turn can tell whether that round said anything at all.
+        let mut sent_before_last_round = 0;
 
         while !result.tool_calls.is_empty() && round < MAX_TOOL_ROUNDS {
             if cancellation.cancelled.load(Ordering::Acquire) {
@@ -2332,9 +2352,14 @@ impl SiGitAgent {
                     .entry(signature)
                     .and_modify(|count| *count += 1)
                     .or_insert(1);
-                let repeated = *repeat_count >= 3;
+                // Repeated status checks are expected for a live background
+                // command. command_output long-polls and the overall round cap
+                // still bounds a confused model without cutting off a real
+                // build or release while it is in progress.
+                let repeated = *repeat_count >= 3 && tc.name != "command_output";
                 if repeated {
                     force_text = true;
+                    stopped_repeating = Some(tc.name.clone());
                     log::warn!(
                         "prompt({}) stopping repeated tool call `{}` after {} attempts",
                         session_id,
@@ -2468,6 +2493,7 @@ impl SiGitAgent {
             // Whatever this round says starts a new paragraph rather than
             // continuing the sentence the tool calls interrupted.
             reply.interrupt();
+            sent_before_last_round = reply.sent.len();
 
             let cancelled_results = tool_results.clone();
             result = match self
@@ -2510,7 +2536,7 @@ impl SiGitAgent {
                         session_id,
                         round
                     );
-                    "Something went wrong — the edits didn't go through. Try rephrasing what you need, or point me at the specific lines.".to_string()
+                    silent_stop_message(stopped_repeating.as_deref(), round)
                 } else {
                     log::warn!(
                         "prompt({}) — model returned empty reply (no tool rounds)",
@@ -2528,6 +2554,25 @@ impl SiGitAgent {
                 self.send_assistant_message(cx, session_id.clone(), final_text)
                     .ok();
             }
+        } else if round > 0 && reply.sent.len() == sent_before_last_round {
+            // Earlier rounds streamed text, but the last one (typically the
+            // forced no-tools round) said nothing. Without a closing message
+            // the turn just stops, and the user can't tell whether it ended,
+            // stalled, or is waiting on them.
+            log::warn!(
+                "prompt({}) — final round after {} tool round(s) produced no text",
+                session_id,
+                round
+            );
+            self.send_assistant_message(
+                cx,
+                session_id.clone(),
+                format!(
+                    "{PARAGRAPH_BREAK}{}",
+                    silent_stop_message(stopped_repeating.as_deref(), round)
+                ),
+            )
+            .ok();
         }
 
         // Persist the completed turn so a restart (or session/load) can pick

{sigit_code-1.5.11 → sigit_code-1.5.13}/src/provider.rs

@@ -40,7 +40,7 @@ const DEFAULT_CLOUD_URL: &str = "https://sigit.si/api/v1";
 /// to be updated together when a tier is added.
 pub const CLOUD_TIERS: &[&str] = &[
     "fast", "balanced", "large", "mini", "air", "pro", "oke", "flux", "apex", "aura", "orbit",
-    "nova",
+    "nova", "flare", "zenith", "prism",
 ];
 
 pub const DEFAULT_CLOUD_TIER: &str = "nova";
@@ -85,6 +85,9 @@ fn tier_to_model(tier: &str) -> String {
         "aura" => "onde-aura",
         "orbit" => "onde-orbit",
         "nova" => "onde-nova",
+        "flare" => "onde-flare",
+        "zenith" => "onde-zenith",
+        "prism" => "onde-prism",
         other => other,
     }
     .to_string()
@@ -267,4 +270,16 @@ mod tests {
         assert_eq!(DEFAULT_CLOUD_TIER, "nova");
         assert_eq!(tier_to_model(DEFAULT_CLOUD_TIER), "onde-nova");
     }
+
+    #[test]
+    fn maps_every_cloud_tier_to_its_own_onde_model_id() {
+        for tier in CLOUD_TIERS {
+            // `oke` is the one tier whose wire id is not its own name.
+            let expected = match *tier {
+                "oke" => "onde-kkk".to_string(),
+                name => format!("onde-{name}"),
+            };
+            assert_eq!(tier_to_model(tier), expected);
+        }
+    }
 }

{sigit_code-1.5.11 → sigit_code-1.5.13}/src/tools.rs

@@ -390,9 +390,10 @@ pub fn all_tools() -> Vec<AgentTool> {
             name: "command_output",
             description: "Get the output a background task (started with run_command's \
                            run_in_background) has produced since your last check, plus its \
-                           status: still running, or exited with an exit code. Poll this \
-                           periodically to follow builds, test suites, and servers. Between \
-                           polls output is buffered up to 50 000 bytes per task; older \
+                           status: still running, or exited with an exit code. By default the \
+                           call waits up to 10 seconds for new output or completion, so call it \
+                           again when the task is still running rather than ending the turn. \
+                           Between polls output is buffered up to 50 000 bytes per task; older \
                            output beyond that is dropped and the truncation is noted.",
             parameters_schema: json!({
                 "type": "object",
@@ -400,6 +401,12 @@ pub fn all_tools() -> Vec<AgentTool> {
                     "task_id": {
                         "type": "integer",
                         "description": "Id of the background task, as returned by run_command with run_in_background."
+                    },
+                    "wait_seconds": {
+                        "type": "integer",
+                        "minimum": 0,
+                        "maximum": 30,
+                        "description": "Seconds to wait for new output or task completion before returning. Defaults to 10; use 0 for an immediate status check."
                     }
                 },
                 "required": ["task_id"],
@@ -458,6 +465,7 @@ async fn execute_tool_impl(name: &str, arguments: &str) -> String {
     match name {
         TASK_TOOL_NAME => exec_task(arguments).await,
         WEB_SEARCH_TOOL_NAME => exec_web_search(arguments).await,
+        "command_output" => exec_command_output_wait(arguments, active_session()).await,
         // Tools discovered from MCP servers are namespaced `mcp__<server>__<tool>`
         // and forwarded to the owning server.
         _ if crate::mcp::is_mcp_tool(name) => crate::mcp::call_tool(name, arguments).await,
@@ -515,7 +523,6 @@ fn execute_sync_tool(name: &str, arguments: &str, owner: Option<&str>) -> String
         "remember" => exec_remember(arguments),
         "delete_file" => exec_delete_file(arguments),
         "run_command" => exec_run_command(arguments, owner),
-        "command_output" => exec_command_output(arguments, owner),
         "kill_command" => exec_kill_command(arguments, owner),
         "skill" => crate::skills::activate_skill(arguments),
         _ => format!("Unknown tool: {name}"),
@@ -2506,9 +2513,38 @@ fn dropped_note(dropped: bool) -> &'static str {
 
 /// `command_output` tool: output since the last poll + running/exited status.
 fn exec_command_output(arguments: &str, owner: Option<&str>) -> String {
+    poll_command_output(arguments, owner, false).text
+}
+
+/// One `command_output` check, with the tool text and whether the task is
+/// still running, so the long-poll loop knows when to keep waiting.
+struct CommandPoll {
+    text: String,
+    /// True while the task's child process is still running.
+    running: bool,
+}
+
+impl CommandPoll {
+    /// A result that ends the wait: an error, or a task that isn't ours.
+    fn done(text: String) -> Self {
+        Self {
+            text,
+            running: false,
+        }
+    }
+}
+
+/// `hold_while_running` is the long-poll's "not my last look" flag: a task
+/// that is still running keeps its output buffered and the returned text is
+/// empty, so the call that finally reports is the one that drains it.
+fn poll_command_output(
+    arguments: &str,
+    owner: Option<&str>,
+    hold_while_running: bool,
+) -> CommandPoll {
     let task_id = match parse_task_id(arguments) {
         Ok(id) => id,
-        Err(err) => return err,
+        Err(err) => return CommandPoll::done(err),
     };
 
     let mut map = lock_tasks();
@@ -2516,16 +2552,23 @@ fn exec_command_output(arguments: &str, owner: Option<&str>) -> String {
         .get_mut(&task_id)
         .filter(|task| task.owner.as_deref() == owner)
     else {
-        return unknown_task(task_id);
+        return CommandPoll::done(unknown_task(task_id));
     };
 
     let was_running = task.exit_code.is_none();
     let exit_code = poll_exit_code(task);
+    if hold_while_running && exit_code.is_none() {
+        return CommandPoll {
+            text: String::new(),
+            running: true,
+        };
+    }
     if was_running && exit_code.is_some() {
         // The child just exited; give the reader threads a moment to flush
         // the final output through the pipes before draining the buffer.
         std::thread::sleep(std::time::Duration::from_millis(100));
     }
+
     let (new_output, dropped) = drain_task_output(task);
 
     let command = &task.command;
@@ -2535,7 +2578,8 @@ fn exec_command_output(arguments: &str, owner: Option<&str>) -> String {
         Some(code) => format!("Task {task_id} (`{command}`) exited with code {code}."),
     };
 
-    if new_output.is_empty() {
+    let running = exit_code.is_none();
+    let text = if new_output.is_empty() {
         format!(
             "{status} No new output since the last check.{}",
             dropped_note(dropped)
@@ -2545,6 +2589,44 @@ fn exec_command_output(arguments: &str, owner: Option<&str>) -> String {
             "{status} New output since the last check:{}\n{new_output}",
             dropped_note(dropped)
         )
+    };
+    CommandPoll { text, running }
+}
+
+/// Long-poll a background task without occupying Tokio's blocking pool while
+/// nothing changes. This keeps model tool rounds from being consumed by a
+/// tight status-check loop.
+async fn exec_command_output_wait(arguments: &str, owner: Option<String>) -> String {
+    const DEFAULT_WAIT_SECONDS: u64 = 10;
+    const MAX_WAIT_SECONDS: u64 = 30;
+    const POLL_INTERVAL: std::time::Duration = std::time::Duration::from_millis(200);
+
+    let wait_seconds = serde_json::from_str::<Value>(arguments)
+        .ok()
+        .and_then(|args| args.get("wait_seconds").and_then(Value::as_u64))
+        .unwrap_or(DEFAULT_WAIT_SECONDS)
+        .min(MAX_WAIT_SECONDS);
+    let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(wait_seconds);
+
+    loop {
+        let arguments = arguments.to_owned();
+        let owner = owner.clone();
+        // Every poll drains the task's buffer, so only the last look may take
+        // the output of a running task; an earlier one would throw it away.
+        let last_look = wait_seconds == 0 || tokio::time::Instant::now() >= deadline;
+        let poll = tokio::task::spawn_blocking(move || {
+            poll_command_output(&arguments, owner.as_deref(), !last_look)
+        })
+        .await
+        .unwrap_or_else(|err| {
+            CommandPoll::done(format!("Error: command_output task failed: {err}"))
+        });
+
+        if last_look || !poll.running {
+            return poll.text;
+        }
+
+        tokio::time::sleep(POLL_INTERVAL).await;
     }
 }
 
@@ -3726,6 +3808,14 @@ mod tests {
         }
     }
 
+    /// The output part of a `command_output` reply. The status line quotes
+    /// the command, so matching the whole reply finds "echo done" whether or
+    /// not `done` was ever printed.
+    fn polled_output(poll: &str) -> &str {
+        poll.split_once("New output since the last check:")
+            .map_or("", |(_, output)| output)
+    }
+
     /// Wait (bounded) for a background task's child to exit.
     fn wait_for_background_exit(task_id: u64) {
         let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
@@ -3783,6 +3873,109 @@ mod tests {
         assert!(combined.contains("done"), "got: {combined}");
     }
 
+    #[tokio::test]
+    async fn test_command_output_waits_for_background_completion() {
+        #[cfg(unix)]
+        let command = "sleep 1; echo done";
+        #[cfg(windows)]
+        let command = "ping -n 2 127.0.0.1 > nul&& echo done";
+
+        let args = serde_json::json!({
+            "command": command,
+            "cwd": std::env::temp_dir(),
+            "run_in_background": true
+        })
+        .to_string();
+        let result = exec_run_command(&args, None);
+        let task_id = background_task_id(&result);
+
+        let poll_args = serde_json::json!({
+            "task_id": task_id,
+            "wait_seconds": 5
+        })
+        .to_string();
+        let poll = exec_command_output_wait(&poll_args, None).await;
+
+        assert!(poll.contains("exited with code 0"), "got: {poll}");
+        assert!(polled_output(&poll).contains("done"), "got: {poll}");
+    }
+
+    #[tokio::test]
+    async fn test_command_output_wait_keeps_output_printed_before_exit() {
+        #[cfg(unix)]
+        let command = "echo start; sleep 1; echo done";
+        #[cfg(windows)]
+        let command = "echo start&& ping -n 2 127.0.0.1 > nul&& echo done";
+
+        let args = serde_json::json!({
+            "command": command,
+            "cwd": std::env::temp_dir(),
+            "run_in_background": true
+        })
+        .to_string();
+        let task_id = background_task_id(&exec_run_command(&args, None));
+
+        let poll_args = serde_json::json!({ "task_id": task_id, "wait_seconds": 5 }).to_string();
+        let poll = exec_command_output_wait(&poll_args, None).await;
+
+        // "start" is printed well before the exit the wait returns on; the
+        // polls in between must not have drained it away.
+        assert!(poll.contains("exited with code 0"), "got: {poll}");
+        assert!(polled_output(&poll).contains("start"), "got: {poll}");
+        assert!(polled_output(&poll).contains("done"), "got: {poll}");
+    }
+
+    #[tokio::test]
+    async fn test_command_output_wait_reports_output_of_a_running_task() {
+        #[cfg(unix)]
+        let command = "echo start; sleep 30";
+        #[cfg(windows)]
+        let command = "echo start&& ping -n 31 127.0.0.1 > nul";
+
+        let args = serde_json::json!({
+            "command": command,
+            "cwd": std::env::temp_dir(),
+            "run_in_background": true
+        })
+        .to_string();
+        let task_id = background_task_id(&exec_run_command(&args, None));
+
+        let poll_args = serde_json::json!({ "task_id": task_id, "wait_seconds": 1 }).to_string();
+        let poll = exec_command_output_wait(&poll_args, None).await;
+
+        assert!(poll.contains("still running"), "got: {poll}");
+        assert!(polled_output(&poll).contains("start"), "got: {poll}");
+        exec_kill_command(&serde_json::json!({ "task_id": task_id }).to_string(), None);
+    }
+
+    #[tokio::test]
+    async fn test_command_output_waits_out_a_quiet_running_task() {
+        #[cfg(unix)]
+        let command = "sleep 30";
+        #[cfg(windows)]
+        let command = "ping -n 31 127.0.0.1 > nul";
+
+        let args = serde_json::json!({
+            "command": command,
+            "cwd": std::env::temp_dir(),
+            "run_in_background": true
+        })
+        .to_string();
+        let task_id = background_task_id(&exec_run_command(&args, None));
+
+        let poll_args = serde_json::json!({ "task_id": task_id, "wait_seconds": 1 }).to_string();
+        let started = std::time::Instant::now();
+        let poll = exec_command_output_wait(&poll_args, None).await;
+
+        assert!(poll.contains("still running"), "got: {poll}");
+        assert!(
+            started.elapsed() >= std::time::Duration::from_millis(900),
+            "an idle task should hold the poll for the whole window, returned after {:?}",
+            started.elapsed()
+        );
+        exec_kill_command(&serde_json::json!({ "task_id": task_id }).to_string(), None);
+    }
+
     #[test]
     fn test_kill_command_stops_background_task() {
         #[cfg(unix)]

{sigit_code-1.5.11 → sigit_code-1.5.13}/tests/acp_endpoint_errors.rs

@@ -20,7 +20,9 @@ use std::time::{Duration, Instant};
 
 use serde_json::{Value, json};
 
-const TIMEOUT: Duration = Duration::from_secs(30);
+/// This is the first test file to launch the freshly built binary, and on the
+/// Intel macOS runner that first launch alone has taken 25 seconds.
+const TIMEOUT: Duration = Duration::from_secs(60);
 
 const ALLOWANCE_MESSAGE: &str = "Monthly siGit Code Cloud allowance reached. It resets at the start of your next billing period.";
 

{sigit_code-1.5.11 → sigit_code-1.5.13}/tests/acp_permissions.rs

@@ -1038,11 +1038,11 @@ fn an_unparseable_tool_call_is_hidden_and_retried() {
 /// 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 repeated_arguments = json!({"path": "missing.txt"}).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_tool_call("call_1", "read_file", &repeated_arguments),
+        sse_tool_call("call_2", "read_file", &repeated_arguments),
+        sse_tool_call("call_3", "read_file", &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>"}}]}),
@@ -1227,6 +1227,113 @@ fn a_kimi_k3_tool_call_emitted_as_text_is_executed_rather_than_rendered() {
     let _ = std::fs::remove_dir_all(&scratch);
 }
 
+#[test]
+fn a_silent_forced_text_round_still_ends_with_a_message() {
+    let repeated_arguments = json!({"path": "missing.txt"}).to_string();
+    let endpoint = start_fake_endpoint(vec![
+        sse_text_then_tool_call(
+            "Checking the file.",
+            "call_1",
+            "read_file",
+            &repeated_arguments,
+        ),
+        sse_tool_call("call_2", "read_file", &repeated_arguments),
+        sse_tool_call("call_3", "read_file", &repeated_arguments),
+        // The forced no-tools round says nothing, as in the stalled thread.
+        sse_body(&[]),
+    ]);
+
+    let scratch =
+        std::env::temp_dir().join(format!("sigit_acp_silent_stop_{}", 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": "read it"}],
+        }),
+    );
+    let (response, rendered) = agent.wait_for_prompt(prompt_id);
+    assert_eq!(response["result"]["stopReason"], "end_turn");
+    assert!(rendered.contains("Checking the file."), "{rendered:?}");
+    assert!(
+        rendered.contains("same `read_file` call") && rendered.contains("continue"),
+        "the turn ended without telling the user why: {rendered:?}"
+    );
+
+    drop(agent);
+    let _ = std::fs::remove_dir_all(&scratch);
+}
+
+#[test]
+fn repeated_command_output_calls_remain_available() {
+    let repeated_arguments = json!({"task_id": 999}).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_text("The background task finished."),
+    ]);
+
+    let scratch =
+        std::env::temp_dir().join(format!("sigit_acp_repeated_poll_{}", 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": "wait for the background task"}],
+        }),
+    );
+    let (response, rendered) = agent.wait_for_prompt(prompt_id);
+    assert_eq!(response["result"]["stopReason"], "end_turn");
+    assert!(rendered.contains("finished"), "got: {rendered:?}");
+
+    let requests = endpoint.requests.lock().unwrap();
+    assert_eq!(requests.len(), 4);
+    assert!(
+        requests[3].get("tools").is_some(),
+        "command_output repetition must not force tools off: {:?}",
+        requests[3]
+    );
+    drop(requests);
+
+    drop(agent);
+    let _ = std::fs::remove_dir_all(&scratch);
+}
+
 #[test]
 fn write_todos_reaches_the_client_as_an_acp_plan() {
     let endpoint = start_fake_endpoint(vec![