sigit-code 1.6.6__tar.gz → 1.6.7__tar.gz

{sigit_code-1.6.6 → sigit_code-1.6.7}/.agents/AGENTS.md

@@ -310,7 +310,11 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   conversation); lifecycle and config handlers hold it throughout, and `handle_prompt` holds it
   through a `WorkspaceHold` that it releases while waiting on an HTTP endpoint or a permission
   answer and retakes (reinstalling its session via `resume_workspace`) before any tool runs. An
-  on-device turn never releases it. Take the session lock first, never the other way round. Tool
+  on-device turn never releases it. Take the session lock first, never the other way round. A turn registers its `PromptCancellation` at
+  the top of `handle_prompt`, before it waits on either lock, and a `PromptRegistration`
+  guard clears it on every return, so a `session/cancel` that arrives while the turn
+  is still queued, switching threads, loading a model or running a slash command ends
+  it as `cancelled`. The checks sit after each of those waits. Tool
   execution, subagents included, still runs one session at a time.
 - **`src/instructions.rs`** — project instruction files, the always-on counterpart to skills.
   Reads `AGENTS.md` (the cross-tool [agents.md](https://agents.md) standard) and `CLAUDE.md`,

{sigit_code-1.6.6 → sigit_code-1.6.7}/AGENTS.md

@@ -310,7 +310,11 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   conversation); lifecycle and config handlers hold it throughout, and `handle_prompt` holds it
   through a `WorkspaceHold` that it releases while waiting on an HTTP endpoint or a permission
   answer and retakes (reinstalling its session via `resume_workspace`) before any tool runs. An
-  on-device turn never releases it. Take the session lock first, never the other way round. Tool
+  on-device turn never releases it. Take the session lock first, never the other way round. A turn registers its `PromptCancellation` at
+  the top of `handle_prompt`, before it waits on either lock, and a `PromptRegistration`
+  guard clears it on every return, so a `session/cancel` that arrives while the turn
+  is still queued, switching threads, loading a model or running a slash command ends
+  it as `cancelled`. The checks sit after each of those waits. Tool
   execution, subagents included, still runs one session at a time.
 - **`src/instructions.rs`** — project instruction files, the always-on counterpart to skills.
   Reads `AGENTS.md` (the cross-tool [agents.md](https://agents.md) standard) and `CLAUDE.md`,

{sigit_code-1.6.6 → sigit_code-1.6.7}/CHANGELOG.md

@@ -1,6 +1,17 @@
 # Changelog
 
-## Unreleased
+## 1.6.7
+
+### Fixed
+
+- **A cancel that arrives before the turn starts is no longer lost.** A prompt
+  now registers for `session/cancel` as soon as it begins, not once it reaches
+  inference. A cancel that lands while the turn is queued on the workspace,
+  switching threads, loading a model, or running a slash command ends it with
+  `cancelled` instead of `end_turn`.
+- **A prompt that is only audio is answered.** A clip with no text or image used
+  to end the turn at once with nothing sent to the model, even though the agent
+  advertises audio.
 
 ## 1.6.6
 

{sigit_code-1.6.6 → sigit_code-1.6.7}/CLAUDE.md

@@ -310,7 +310,11 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   conversation); lifecycle and config handlers hold it throughout, and `handle_prompt` holds it
   through a `WorkspaceHold` that it releases while waiting on an HTTP endpoint or a permission
   answer and retakes (reinstalling its session via `resume_workspace`) before any tool runs. An
-  on-device turn never releases it. Take the session lock first, never the other way round. Tool
+  on-device turn never releases it. Take the session lock first, never the other way round. A turn registers its `PromptCancellation` at
+  the top of `handle_prompt`, before it waits on either lock, and a `PromptRegistration`
+  guard clears it on every return, so a `session/cancel` that arrives while the turn
+  is still queued, switching threads, loading a model or running a slash command ends
+  it as `cancelled`. The checks sit after each of those waits. Tool
   execution, subagents included, still runs one session at a time.
 - **`src/instructions.rs`** — project instruction files, the always-on counterpart to skills.
   Reads `AGENTS.md` (the cross-tool [agents.md](https://agents.md) standard) and `CLAUDE.md`,

{sigit_code-1.6.6 → sigit_code-1.6.7}/Cargo.lock

@@ -5901,7 +5901,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sigit"
-version = "1.6.6"
+version = "1.6.7"
 dependencies = [
  "agent-client-protocol",
  "anyhow",

{sigit_code-1.6.6 → sigit_code-1.6.7}/Cargo.toml

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

{sigit_code-1.6.6 → sigit_code-1.6.7}/PKG-INFO

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

{sigit_code-1.6.6 → sigit_code-1.6.7}/src/main.rs

@@ -465,6 +465,21 @@ impl PromptCancellation {
     }
 }
 
+/// Removes a turn's cancellation from the agent's registry when the turn ends,
+/// whichever way it returns.
+struct PromptRegistration<'a> {
+    agent: &'a SiGitAgent,
+    session_id: SessionId,
+    cancellation: Arc<PromptCancellation>,
+}
+
+impl Drop for PromptRegistration<'_> {
+    fn drop(&mut self) {
+        self.agent
+            .finish_prompt(&self.session_id, &self.cancellation);
+    }
+}
+
 enum DrainTurnError {
     Backend(backend::BackendError),
     Cancelled,
@@ -3063,10 +3078,31 @@ impl SiGitAgent {
             return Ok(PromptResponse::new(StopReason::Cancelled));
         }
 
+        // Registered before anything that can wait, so a `session/cancel` that
+        // lands while this turn is still queued on the workspace, switching
+        // sessions or loading a model is seen. The session lock is held, so the
+        // slot can only be this turn's. The guard clears it on every return.
+        let cancellation = Arc::new(PromptCancellation::default());
+        self.prompt_cancellations
+            .lock()
+            .unwrap()
+            .insert(session_id.to_string(), Arc::clone(&cancellation));
+        let _registration = PromptRegistration {
+            agent: self,
+            session_id: session_id.clone(),
+            cancellation: Arc::clone(&cancellation),
+        };
+
         // Everything below (slash commands included) acts on the live session,
         // so it has to be this one. Resource links are read relative to its cwd.
         let mut workspace = WorkspaceHold::acquire(&self.workspace_lock).await;
+        if cancellation.cancelled.load(Ordering::Acquire) {
+            return Ok(PromptResponse::new(StopReason::Cancelled));
+        }
         self.activate_session(&session_id).await?;
+        if cancellation.cancelled.load(Ordering::Acquire) {
+            return Ok(PromptResponse::new(StopReason::Cancelled));
+        }
 
         // log every block so we can debug @ references and file context
         for (i, block) in args.prompt.iter().enumerate() {
@@ -3204,7 +3240,7 @@ impl SiGitAgent {
 
         let user_text = parts.join("\n");
 
-        if user_text.trim().is_empty() && images.is_empty() {
+        if user_text.trim().is_empty() && images.is_empty() && audio.is_empty() {
             return Ok(PromptResponse::new(StopReason::EndTurn));
         }
 
@@ -3230,17 +3266,18 @@ impl SiGitAgent {
                 match commands::resolve_command(&command) {
                     Some(custom) => commands::render(&custom.body, argument.as_deref()),
                     None => {
-                        return exec_slash_acp(
-                            self,
-                            cx,
-                            session_id,
-                            SlashCommand::Unknown(command, argument),
-                        )
-                        .await;
+                        return self
+                            .run_slash(
+                                cx,
+                                session_id,
+                                SlashCommand::Unknown(command, argument),
+                                &cancellation,
+                            )
+                            .await;
                     }
                 }
             }
-            Some(command) => return exec_slash_acp(self, cx, session_id, command).await,
+            Some(command) => return self.run_slash(cx, session_id, command, &cancellation).await,
             None => user_text,
         };
 
@@ -3267,7 +3304,12 @@ impl SiGitAgent {
         {
             if self.auto_load_local_model {
                 self.start_startup_model_load_if_needed();
-                self.await_model_ready(cx, &session_id).await?;
+                tokio::select! {
+                    ready = self.await_model_ready(cx, &session_id) => ready?,
+                    () = cancellation.cancelled() => {
+                        return Ok(PromptResponse::new(StopReason::Cancelled));
+                    }
+                }
             } else {
                 self.send_assistant_message(
                     cx,
@@ -3280,11 +3322,9 @@ impl SiGitAgent {
             }
         }
 
-        let cancellation = Arc::new(PromptCancellation::default());
-        self.prompt_cancellations
-            .lock()
-            .unwrap()
-            .insert(session_id.to_string(), Arc::clone(&cancellation));
+        if cancellation.cancelled.load(Ordering::Acquire) {
+            return Ok(PromptResponse::new(StopReason::Cancelled));
+        }
 
         // ── tool-calling loop ────────────────────────────────────────────
         // send message → execute any tool calls → feed results back
@@ -3987,6 +4027,24 @@ impl SiGitAgent {
         }
     }
 
+    /// Run a built-in slash command as a turn. A `session/cancel` ends it with
+    /// `Cancelled`; only `/compact` and `/load` take long enough to notice.
+    async fn run_slash(
+        &self,
+        cx: &ConnectionTo<Client>,
+        session_id: SessionId,
+        command: SlashCommand,
+        cancellation: &PromptCancellation,
+    ) -> agent_client_protocol::Result<PromptResponse> {
+        if cancellation.cancelled.load(Ordering::Acquire) {
+            return Ok(PromptResponse::new(StopReason::Cancelled));
+        }
+        tokio::select! {
+            response = exec_slash_acp(self, cx, session_id, command) => response,
+            () = cancellation.cancelled() => Ok(PromptResponse::new(StopReason::Cancelled)),
+        }
+    }
+
     fn finish_prompt(&self, session_id: &SessionId, cancellation: &Arc<PromptCancellation>) {
         let key = session_id.to_string();
         let mut active = self.prompt_cancellations.lock().unwrap();
@@ -6406,6 +6464,71 @@ mod tests {
         assert!(agent.active_session.lock().unwrap().is_none());
     }
 
+    #[tokio::test]
+    async fn a_turn_leaves_no_cancellation_behind_however_it_returns() {
+        let agent = SiGitAgent::new(
+            Arc::new(ChatEngine::new()),
+            default_local_model_config(),
+            Arc::new(AtomicBool::new(true)),
+            Arc::new(AtomicBool::new(false)),
+            Arc::new(std::sync::Mutex::new(None)),
+            false,
+            false,
+        );
+        let session_id = SessionId::new("early");
+        let turn = Arc::new(PromptCancellation::default());
+        agent
+            .prompt_cancellations
+            .lock()
+            .unwrap()
+            .insert("early".into(), Arc::clone(&turn));
+        let registration = PromptRegistration {
+            agent: &agent,
+            session_id: session_id.clone(),
+            cancellation: Arc::clone(&turn),
+        };
+
+        // A cancel that arrives before the turn reaches inference is recorded
+        // and stays visible to every check the turn makes afterwards.
+        agent
+            .handle_cancel(CancelNotification::new(session_id.clone()))
+            .await
+            .unwrap();
+        assert!(turn.cancelled.load(Ordering::Acquire));
+        tokio::time::timeout(std::time::Duration::from_millis(50), turn.cancelled())
+            .await
+            .expect("a pre-cancelled turn must resolve at once");
+
+        drop(registration);
+        assert!(agent.prompt_cancellations.lock().unwrap().is_empty());
+    }
+
+    #[tokio::test]
+    async fn a_finished_turn_does_not_remove_its_successors_cancellation() {
+        let agent = SiGitAgent::new(
+            Arc::new(ChatEngine::new()),
+            default_local_model_config(),
+            Arc::new(AtomicBool::new(true)),
+            Arc::new(AtomicBool::new(false)),
+            Arc::new(std::sync::Mutex::new(None)),
+            false,
+            false,
+        );
+        let old = Arc::new(PromptCancellation::default());
+        let new = Arc::new(PromptCancellation::default());
+        agent
+            .prompt_cancellations
+            .lock()
+            .unwrap()
+            .insert("s".into(), Arc::clone(&new));
+        drop(PromptRegistration {
+            agent: &agent,
+            session_id: SessionId::new("s"),
+            cancellation: old,
+        });
+        assert!(agent.prompt_cancellations.lock().unwrap().contains_key("s"));
+    }
+
     #[tokio::test]
     async fn cancel_signals_only_the_matching_active_prompt() {
         let agent = SiGitAgent::new(

{sigit_code-1.6.6 → sigit_code-1.6.7}/tests/acp_audio.rs

@@ -308,3 +308,48 @@ fn a_cloud_tier_gets_the_text_and_the_user_is_told() {
         "the user must be told the clip was left out: {updates}"
     );
 }
+
+#[test]
+fn an_audio_only_prompt_reaches_the_endpoint() {
+    let endpoint = start_fake_endpoint(vec![sse_text("heard it")]);
+    let scratch = std::env::temp_dir().join(format!("sigit_acp_audio_only_{}", std::process::id()));
+    let config_dir = scratch.join("config");
+    let project = scratch.join("project");
+    std::fs::create_dir_all(&config_dir).unwrap();
+    std::fs::create_dir_all(&project).unwrap();
+
+    let mut agent = spawn_agent(endpoint.port, &config_dir, "scripted-audio-model");
+    let id = agent.request(
+        "initialize",
+        json!({"protocolVersion": 1, "clientCapabilities": {}}),
+    );
+    agent.wait_for_response(id);
+    let id = agent.request("session/new", json!({"cwd": project, "mcpServers": []}));
+    let session_id = agent.wait_for_response(id)["result"]["sessionId"]
+        .as_str()
+        .expect("session id")
+        .to_string();
+
+    let id = agent.request(
+        "session/prompt",
+        json!({
+            "sessionId": session_id,
+            "prompt": [{"type": "audio", "mimeType": "audio/wav", "data": CLIP}],
+        }),
+    );
+    let response = agent.wait_for_response(id);
+    assert_eq!(response["result"]["stopReason"], "end_turn");
+
+    let requests = endpoint.requests.lock().unwrap();
+    let request = requests
+        .first()
+        .expect("a clip with no text is still a prompt, so the endpoint must see it");
+    assert!(
+        request.to_string().contains(CLIP),
+        "the clip must reach the endpoint: {request}"
+    );
+
+    drop(requests);
+    drop(agent);
+    let _ = std::fs::remove_dir_all(&scratch);
+}