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

{sigit_code-1.5.10 → sigit_code-1.5.12}/.agents/AGENTS.md

@@ -111,9 +111,13 @@ The agent loop is backend-agnostic. The flow: a turn (messages + tool specs) goe
 feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete backend.
 
 - **`src/main.rs`** — entry point, mode dispatch, the full ACP `Agent` impl (session lifecycle:
-  new/load/fork/prompt/cancel, config options, slash-command advertisement), and the `SYSTEM_PROMPT`
-  (note: it bakes in smbCloud-specific context the agent should use when the repo is clearly
-  smbCloud, and stay general otherwise).
+  new/load/fork/prompt/cancel, config options, slash-command advertisement), and the `SYSTEM_PROMPT`.
+  ACP session state owns its roots, conversation, and selected model even though the process has
+  one live backend; activating a thread parks and restores all three. Unknown session ids are
+  rejected instead of silently borrowing the active thread's cwd. Prompt cancellation is routed
+  outside `turn_lock`, which lets a client cancel the turn currently holding that lock. The
+  `SYSTEM_PROMPT` bakes in smbCloud-specific context the agent should use when the repo is clearly
+  smbCloud, and stay general otherwise.
 - **`src/backend.rs`** — the `InferenceBackend` trait and neutral types (`ToolSpec`, `ToolCall`,
   `ToolResult`, `TurnResult`). Two impls: `LocalBackend` (on-device via `onde::ChatEngine`) and
   `OpenAiBackend` (any OpenAI-compatible HTTP endpoint). A `BackendError` is user-facing: the
@@ -123,6 +127,10 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   endpoint can also fail *after* the response is open, reporting it as a `data:` frame holding
   the same envelope; that frame has no `choices`, so `consume_stream` has to check for it
   explicitly or it parses as an empty chunk and the turn ends looking like an empty answer.
+  Some models write tool calls into content as text; `src/inline_tool_calls.rs` recovers the
+  well-formed ones. A block that doesn't parse (or never closes) is dropped from both the reply
+  and history, and `OpenAiBackend::complete` retries once with a note telling the model the call
+  didn't run. Leaving the raw block in history makes the model invent `<function_results>` later.
 - **`src/provider.rs`** — decides *which* backend serves inference. Resolution order, first match
   wins: (1) override via `OPENAI_BASE_URL`+`OPENAI_API_KEY` or active profile in
   `~/.config/sigit/providers.toml`; (2) siGit Code Cloud when logged in; (3) on-device.
@@ -131,7 +139,8 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   `multi_edit`, `delete_file`, `run_command`, `write_todos`, `remember`. Add a tool in both the
   spec list (`all_tools`) and the execute `match` (`execute_tool`). `run_command` also enforces
   commit attribution: when a command creates a new commit that lacks the
-  `Co-Authored-By: siGit Code` trailer (`COMMIT_CO_AUTHOR_TRAILER`), it amends the trailer in —
+  `Co-Authored-By: siGit Code` trailer (`commit_co_author_trailer()`, which reads
+  `siGit Code v<version>-<acp|tui|headless>` from the surface `main` sets via `set_surface`), it amends the trailer in —
   unless the commit already exists on a remote, which is never rewritten. Every child process it
   spawns (`spawn_shell`, the `git` helpers, and `hooks.rs`) sets `stdin` to null and never
   inherits it: in ACP mode sigit's stdin is the JSON-RPC pipe from the editor, so a command that
@@ -243,12 +252,32 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   `handle_initialize` is what makes the rest of this reachable — without it Zed keeps the first
   root, drops the others, and shows "This agent doesn't currently support multi-root workspaces".
   The process still has one working directory, so the extra roots live in a
-  process-global here and `project_dirs()` returns cwd-first, extras after. Project-local
+  process-global here and `project_dirs()` returns cwd-first, extras after.
+  One process also serves every thread the editor has open, so that global
+  (with the cwd, the backend conversation, and the background-task owner in
+  `tools.rs`) always belongs to the *live* session: `main.rs` keeps a
+  `SessionState` per session id and `activate_session` parks the live one and
+  installs the requested one before any prompt or config change runs. Don't
+  read another session's roots from the global. Project-local
   discovery reads it: skills, slash commands, subagent types, and instruction files all scan
   every root. MCP is deliberately not on that list — `mcp::init` runs once at startup, before
   any session exists, so a second root's `.sigit/mcp.toml` has nobody to tell.
 - **`src/chat.rs`** — the Unix-only ratatui TUI. Loading-spinner phase then chat; uses
   `tokio::select!` to multiplex terminal events with streaming tokens.
+- **`src/headless.rs`** — non-interactive `sigit run` execution for scripts, CI, and Factory
+  clients. The legacy `-p` form reaches the same parser. Every new run gets a UUID session id;
+  `--resume <id>` restores that session through `session_store`, and `--output jsonl` emits a
+  structured session/delta/tool/result stream while logs stay on stderr. Headless permission
+  prompts collapse to denial unless the tool was pre-approved with `--allow-tool`.
+- **`src/session_store.rs`** — durable conversations: one JSON-lines history file per session at
+  `$SIGIT_CONFIG_DIR/sessions/<id>.jsonl`, written atomically, restorable into either backend.
+  Each save also writes a `<id>.meta.json` sidecar naming the session's `cwd` and the extra roots
+  of a multi-root project. That sidecar is what makes a thread *listable*: ACP's `session/list`
+  (advertised as `sessionCapabilities.list`, handled by `handle_list_sessions` in `main.rs` — the
+  editor's "Import Threads" picker) must report an absolute `cwd` per session and may filter on
+  it, so a session without one is skipped there while still reopening by id through
+  `session/load`. Sidecars are written at save time, not at session start, so a thread nobody
+  spoke in leaves nothing behind.
 - **`src/setup.rs`** — model cache location, local model discovery, selected-model persistence.
   Must run (`setup_shared_model_cache`) *before* anything touches `ChatEngine`/`hf-hub`, since
   those read env vars once at init.
@@ -322,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.10/.claude → sigit_code-1.5.12/.agents}/skills/agent-client-protocol/SKILL.md

@@ -196,6 +196,7 @@ the connection and the agent anymore. Don't reintroduce the mpsc forwarder patte
 | `NewSessionRequest` | `handle_new_session` | sets cwd, resets history, advertises commands + config options |
 | `LoadSessionRequest` | `handle_load_session` | like new_session; gated by `load_session(true)` capability |
 | `ForkSessionRequest` | `handle_fork_session` | gated by `unstable_session_fork` + `SessionForkCapabilities` |
+| `ListSessionsRequest` | `handle_list_sessions` | the editor's "Import Threads" picker; gated by `SessionListCapabilities` |
 | `PromptRequest` | `handle_prompt` | the turn: parse blocks → slash commands or tool-calling loop |
 | `SetSessionConfigOptionRequest` | `handle_set_session_config_option` | the Zed model picker — switches/downloads models |
 | `CancelNotification` | `handle_cancel` | notification, no response |
@@ -226,7 +227,8 @@ Ok(InitializeResponse::new(ProtocolVersion::V1)        // use V1, not args.proto
             .load_session(true)                        // enables LoadSessionRequest
             .session_capabilities(
                 SessionCapabilities::new()
-                    .fork(SessionForkCapabilities::new()),  // enables ForkSessionRequest
+                    .fork(SessionForkCapabilities::new())   // enables ForkSessionRequest
+                    .list(SessionListCapabilities::new()),  // enables ListSessionsRequest
             ),
     )
     .meta(initialize_meta()))                          // free-form Meta (see below)
@@ -573,6 +575,14 @@ Editor                                Agent
 12. **Store `SessionId` as `SessionId`**, not `String`, so `==` is clean.
 13. **`SetSessionConfigOptionResponse::new(config_options)`** — the response
     carries the *rebuilt* options so the picker reflects the new current value.
+14. **`session/list` needs a `cwd` per session, which history alone can't
+    supply.** `SessionInfo` requires an absolute `cwd` and the request may
+    filter on it, so `session_store` writes a `<id>.meta.json` sidecar next to
+    each saved thread; sessions without one are skipped by
+    `handle_list_sessions` rather than guessed at. Advertising
+    `SessionCapabilities::new().list(SessionListCapabilities::new())` is what
+    turns the editor's "Import Threads" picker from an error banner into a
+    list.
 
 ---
 

sigit_code-1.5.12/.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.10/.agents → sigit_code-1.5.12/.claude}/skills/agent-client-protocol/SKILL.md

@@ -196,6 +196,7 @@ the connection and the agent anymore. Don't reintroduce the mpsc forwarder patte
 | `NewSessionRequest` | `handle_new_session` | sets cwd, resets history, advertises commands + config options |
 | `LoadSessionRequest` | `handle_load_session` | like new_session; gated by `load_session(true)` capability |
 | `ForkSessionRequest` | `handle_fork_session` | gated by `unstable_session_fork` + `SessionForkCapabilities` |
+| `ListSessionsRequest` | `handle_list_sessions` | the editor's "Import Threads" picker; gated by `SessionListCapabilities` |
 | `PromptRequest` | `handle_prompt` | the turn: parse blocks → slash commands or tool-calling loop |
 | `SetSessionConfigOptionRequest` | `handle_set_session_config_option` | the Zed model picker — switches/downloads models |
 | `CancelNotification` | `handle_cancel` | notification, no response |
@@ -226,7 +227,8 @@ Ok(InitializeResponse::new(ProtocolVersion::V1)        // use V1, not args.proto
             .load_session(true)                        // enables LoadSessionRequest
             .session_capabilities(
                 SessionCapabilities::new()
-                    .fork(SessionForkCapabilities::new()),  // enables ForkSessionRequest
+                    .fork(SessionForkCapabilities::new())   // enables ForkSessionRequest
+                    .list(SessionListCapabilities::new()),  // enables ListSessionsRequest
             ),
     )
     .meta(initialize_meta()))                          // free-form Meta (see below)
@@ -573,6 +575,14 @@ Editor                                Agent
 12. **Store `SessionId` as `SessionId`**, not `String`, so `==` is clean.
 13. **`SetSessionConfigOptionResponse::new(config_options)`** — the response
     carries the *rebuilt* options so the picker reflects the new current value.
+14. **`session/list` needs a `cwd` per session, which history alone can't
+    supply.** `SessionInfo` requires an absolute `cwd` and the request may
+    filter on it, so `session_store` writes a `<id>.meta.json` sidecar next to
+    each saved thread; sessions without one are skipped by
+    `handle_list_sessions` rather than guessed at. Advertising
+    `SessionCapabilities::new().list(SessionListCapabilities::new())` is what
+    turns the editor's "Import Threads" picker from an error banner into a
+    list.
 
 ---
 

{sigit_code-1.5.10 → sigit_code-1.5.12}/.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.10 → sigit_code-1.5.12}/.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.10 → sigit_code-1.5.12}/.gitignore

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

{sigit_code-1.5.10 → sigit_code-1.5.12}/AGENTS.md

@@ -111,9 +111,13 @@ The agent loop is backend-agnostic. The flow: a turn (messages + tool specs) goe
 feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete backend.
 
 - **`src/main.rs`** — entry point, mode dispatch, the full ACP `Agent` impl (session lifecycle:
-  new/load/fork/prompt/cancel, config options, slash-command advertisement), and the `SYSTEM_PROMPT`
-  (note: it bakes in smbCloud-specific context the agent should use when the repo is clearly
-  smbCloud, and stay general otherwise).
+  new/load/fork/prompt/cancel, config options, slash-command advertisement), and the `SYSTEM_PROMPT`.
+  ACP session state owns its roots, conversation, and selected model even though the process has
+  one live backend; activating a thread parks and restores all three. Unknown session ids are
+  rejected instead of silently borrowing the active thread's cwd. Prompt cancellation is routed
+  outside `turn_lock`, which lets a client cancel the turn currently holding that lock. The
+  `SYSTEM_PROMPT` bakes in smbCloud-specific context the agent should use when the repo is clearly
+  smbCloud, and stay general otherwise.
 - **`src/backend.rs`** — the `InferenceBackend` trait and neutral types (`ToolSpec`, `ToolCall`,
   `ToolResult`, `TurnResult`). Two impls: `LocalBackend` (on-device via `onde::ChatEngine`) and
   `OpenAiBackend` (any OpenAI-compatible HTTP endpoint). A `BackendError` is user-facing: the
@@ -123,6 +127,10 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   endpoint can also fail *after* the response is open, reporting it as a `data:` frame holding
   the same envelope; that frame has no `choices`, so `consume_stream` has to check for it
   explicitly or it parses as an empty chunk and the turn ends looking like an empty answer.
+  Some models write tool calls into content as text; `src/inline_tool_calls.rs` recovers the
+  well-formed ones. A block that doesn't parse (or never closes) is dropped from both the reply
+  and history, and `OpenAiBackend::complete` retries once with a note telling the model the call
+  didn't run. Leaving the raw block in history makes the model invent `<function_results>` later.
 - **`src/provider.rs`** — decides *which* backend serves inference. Resolution order, first match
   wins: (1) override via `OPENAI_BASE_URL`+`OPENAI_API_KEY` or active profile in
   `~/.config/sigit/providers.toml`; (2) siGit Code Cloud when logged in; (3) on-device.
@@ -131,7 +139,8 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   `multi_edit`, `delete_file`, `run_command`, `write_todos`, `remember`. Add a tool in both the
   spec list (`all_tools`) and the execute `match` (`execute_tool`). `run_command` also enforces
   commit attribution: when a command creates a new commit that lacks the
-  `Co-Authored-By: siGit Code` trailer (`COMMIT_CO_AUTHOR_TRAILER`), it amends the trailer in —
+  `Co-Authored-By: siGit Code` trailer (`commit_co_author_trailer()`, which reads
+  `siGit Code v<version>-<acp|tui|headless>` from the surface `main` sets via `set_surface`), it amends the trailer in —
   unless the commit already exists on a remote, which is never rewritten. Every child process it
   spawns (`spawn_shell`, the `git` helpers, and `hooks.rs`) sets `stdin` to null and never
   inherits it: in ACP mode sigit's stdin is the JSON-RPC pipe from the editor, so a command that
@@ -243,12 +252,32 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   `handle_initialize` is what makes the rest of this reachable — without it Zed keeps the first
   root, drops the others, and shows "This agent doesn't currently support multi-root workspaces".
   The process still has one working directory, so the extra roots live in a
-  process-global here and `project_dirs()` returns cwd-first, extras after. Project-local
+  process-global here and `project_dirs()` returns cwd-first, extras after.
+  One process also serves every thread the editor has open, so that global
+  (with the cwd, the backend conversation, and the background-task owner in
+  `tools.rs`) always belongs to the *live* session: `main.rs` keeps a
+  `SessionState` per session id and `activate_session` parks the live one and
+  installs the requested one before any prompt or config change runs. Don't
+  read another session's roots from the global. Project-local
   discovery reads it: skills, slash commands, subagent types, and instruction files all scan
   every root. MCP is deliberately not on that list — `mcp::init` runs once at startup, before
   any session exists, so a second root's `.sigit/mcp.toml` has nobody to tell.
 - **`src/chat.rs`** — the Unix-only ratatui TUI. Loading-spinner phase then chat; uses
   `tokio::select!` to multiplex terminal events with streaming tokens.
+- **`src/headless.rs`** — non-interactive `sigit run` execution for scripts, CI, and Factory
+  clients. The legacy `-p` form reaches the same parser. Every new run gets a UUID session id;
+  `--resume <id>` restores that session through `session_store`, and `--output jsonl` emits a
+  structured session/delta/tool/result stream while logs stay on stderr. Headless permission
+  prompts collapse to denial unless the tool was pre-approved with `--allow-tool`.
+- **`src/session_store.rs`** — durable conversations: one JSON-lines history file per session at
+  `$SIGIT_CONFIG_DIR/sessions/<id>.jsonl`, written atomically, restorable into either backend.
+  Each save also writes a `<id>.meta.json` sidecar naming the session's `cwd` and the extra roots
+  of a multi-root project. That sidecar is what makes a thread *listable*: ACP's `session/list`
+  (advertised as `sessionCapabilities.list`, handled by `handle_list_sessions` in `main.rs` — the
+  editor's "Import Threads" picker) must report an absolute `cwd` per session and may filter on
+  it, so a session without one is skipped there while still reopening by id through
+  `session/load`. Sidecars are written at save time, not at session start, so a thread nobody
+  spoke in leaves nothing behind.
 - **`src/setup.rs`** — model cache location, local model discovery, selected-model persistence.
   Must run (`setup_shared_model_cache`) *before* anything touches `ChatEngine`/`hf-hub`, since
   those read env vars once at init.
@@ -322,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.10 → sigit_code-1.5.12}/CHANGELOG.md

@@ -1,5 +1,133 @@
 # Changelog
 
+## 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 run` drives the agent headlessly with resumable sessions.** A new
+  non-interactive subcommand runs a prompt through the same agent loop as the
+  editor and terminal surfaces, for scripts, CI, and Factory clients. Every run
+  gets a UUID session id, writes a JSON-lines history file under
+  `~/.config/sigit/sessions/`, and can be restored with `--resume <id>`.
+  `--output jsonl` emits a structured session/delta/tool/result stream on
+  stdout while logs stay on stderr, and `--allow-tool` pre-approves a tool so
+  permission prompts collapse to denial in a non-interactive context. The
+  legacy `-p` form still works. Each run also rewrites the session metadata
+  with its own cwd and extra roots, so resuming keeps multi-root projects
+
+- **Saved threads can be imported into the editor.** siGit Code now advertises
+  ACP's `sessionCapabilities.list` and answers `session/list`, so Zed's "Import
+  Threads" picker offers the conversations stored under
+  `~/.config/sigit/sessions/` instead of reporting that the agent doesn't
+  support the capability. A saved session gets a sidecar recording the project
+  directory it ran in — listing reports that `cwd`, the extra roots of a
+  multi-root project, an ISO 8601 last-activity timestamp, and a title taken
+  from the first user message — and a request may filter on `cwd` so one
+  project is never offered another's threads. Threads saved before this have no
+  sidecar and are not listed; they still reopen by id through `session/load`
+
+### Changed
+
+- **The commit trailer names the siGit Code version and surface.** Commits
+  siGit Code makes now end with
+  `Co-Authored-By: siGit Code v<version>-<surface> <noreply@sigit.si>` instead
+  of the bare name, where the surface is `acp` (an editor), `tui` (the
+  terminal UI), or `headless` (`sigit run`). The model changes from session to
+  session; the version and surface tell you which build of the agent wrote the
+  commit and how it was driven. GitHub still credits the co-author, since it
+  matches on the address. A commit that already carries a siGit Code trailer
+  from an older version is left alone
+
+- **The terminal UI's model knows which directory the project is in.** The
+  editor (ACP) and headless paths put the working directory in the system
+  prompt, but the terminal UI only added the project's instruction files, so
+  on `/init` a small on-device model invented a `AGENTS.md` path and failed.
+  All three places the terminal UI builds a prompt now go through the same
+  session context path the ACP sessions get. The cloud tier switch had also
+  been dropping the instruction files; that's fixed too
+
+- **An empty `write_todos` list clears the plan.** `write_todos` rejected an
+  empty list, so the model had no way to clear a finished checklist and the
+  last plan stayed in the editor until the session ended. An empty list now
+  returns "Task list cleared." and goes to the client as an ACP plan with no
+  entries. The tool description tells the model it can do this
+
+- **`sigit run` gives clearer usage errors.** A second positional prompt says
+  "unexpected extra argument", a bare `sigit run` says "missing prompt", and a
+  mistyped flag like `--quite` is rejected instead of becoming the prompt
+
+### Fixed
+
+- **Each ACP session keeps its own roots, conversation, and tasks.** Zed runs
+  one siGit process for every open thread, but the process had a single cwd,
+  workspace root list, backend conversation, and background task table. The
+  most recent session owned all of them, so a prompt from an older thread ran
+  against another repo with another thread's history. A `SessionState` is now
+  kept per session id; before a prompt or config change runs, the live
+  conversation is parked and the requested session's cwd, extra roots, and
+  conversation are installed, rebuilding the system prompt from its roots.
+  `new`/`load`/`fork` share a single session-opening path, and fork carries the
+  source thread's conversation. Background tasks are scoped to the session that
+  started them, opening a session no longer wipes every other session's
+  permission grants, and model selection is routed per session
+
+- **New sessions no longer carry the previous thread's history.** Opening a
+  new thread in Zed showed a `[Conversation summary]` from an earlier session.
+  The session handlers cleared the on-device engine but not the history a cloud
+  backend keeps for itself, and the startup routing to the cloud tier then
+  carried that history into the installed backend. A provider override had the
+  same leak. All session entry points now share a path that strips stale
+  history too, and unknown session ids are rejected instead of borrowing the
+  live thread's state
+
+- **Unparseable tool-call markup is hidden and retried, not shown as text.**
+  Some models write tool calls into the reply as text. Well-formed blocks were
+  already recovered and run, but a block that failed to parse or never closed
+  was printed to the editor as-is and stayed in history, so the model later
+  read back a call it had "made" with no result and began writing invented
+  `<function_results>`. The scanner now reports those blocks as malformed; the
+  backend drops them from the reply and history, and when the only tool call
+  was malformed the model gets one retry telling it the call didn't run. A
+  block that merely *mentions* a tool-call marker (a backticked `<tool_call>` or an
+  unclosed XTML `<|open|>tools`) is now kept as prose, so a reply explaining
+  the scanner no longer loses everything after the first marker. The
+  non-streamed path now strips broken blocks beside structured calls and runs
+  any inline calls that did parse, matching the streaming path
+
+- **The co-author trailer ends a conflicted merge commit.** Finishing a
+  conflicted merge with `git commit --no-edit` keeps git's `# Conflicts:` list
+  in the message, since no editor runs to strip it. When siGit Code then added
+  its trailer, the trailer went in above that list, so it was no longer the last
+  paragraph and GitHub didn't credit the co-author. The amend now drops the
+  leftover comment block and puts the trailer last. It also fixes a commit
+  that already has the trailer but still ends in that block
+
 ## 1.5.10
 
 ### What changed

{sigit_code-1.5.10 → sigit_code-1.5.12}/CLAUDE.md

@@ -111,9 +111,13 @@ The agent loop is backend-agnostic. The flow: a turn (messages + tool specs) goe
 feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete backend.
 
 - **`src/main.rs`** — entry point, mode dispatch, the full ACP `Agent` impl (session lifecycle:
-  new/load/fork/prompt/cancel, config options, slash-command advertisement), and the `SYSTEM_PROMPT`
-  (note: it bakes in smbCloud-specific context the agent should use when the repo is clearly
-  smbCloud, and stay general otherwise).
+  new/load/fork/prompt/cancel, config options, slash-command advertisement), and the `SYSTEM_PROMPT`.
+  ACP session state owns its roots, conversation, and selected model even though the process has
+  one live backend; activating a thread parks and restores all three. Unknown session ids are
+  rejected instead of silently borrowing the active thread's cwd. Prompt cancellation is routed
+  outside `turn_lock`, which lets a client cancel the turn currently holding that lock. The
+  `SYSTEM_PROMPT` bakes in smbCloud-specific context the agent should use when the repo is clearly
+  smbCloud, and stay general otherwise.
 - **`src/backend.rs`** — the `InferenceBackend` trait and neutral types (`ToolSpec`, `ToolCall`,
   `ToolResult`, `TurnResult`). Two impls: `LocalBackend` (on-device via `onde::ChatEngine`) and
   `OpenAiBackend` (any OpenAI-compatible HTTP endpoint). A `BackendError` is user-facing: the
@@ -123,6 +127,10 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   endpoint can also fail *after* the response is open, reporting it as a `data:` frame holding
   the same envelope; that frame has no `choices`, so `consume_stream` has to check for it
   explicitly or it parses as an empty chunk and the turn ends looking like an empty answer.
+  Some models write tool calls into content as text; `src/inline_tool_calls.rs` recovers the
+  well-formed ones. A block that doesn't parse (or never closes) is dropped from both the reply
+  and history, and `OpenAiBackend::complete` retries once with a note telling the model the call
+  didn't run. Leaving the raw block in history makes the model invent `<function_results>` later.
 - **`src/provider.rs`** — decides *which* backend serves inference. Resolution order, first match
   wins: (1) override via `OPENAI_BASE_URL`+`OPENAI_API_KEY` or active profile in
   `~/.config/sigit/providers.toml`; (2) siGit Code Cloud when logged in; (3) on-device.
@@ -131,7 +139,8 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   `multi_edit`, `delete_file`, `run_command`, `write_todos`, `remember`. Add a tool in both the
   spec list (`all_tools`) and the execute `match` (`execute_tool`). `run_command` also enforces
   commit attribution: when a command creates a new commit that lacks the
-  `Co-Authored-By: siGit Code` trailer (`COMMIT_CO_AUTHOR_TRAILER`), it amends the trailer in —
+  `Co-Authored-By: siGit Code` trailer (`commit_co_author_trailer()`, which reads
+  `siGit Code v<version>-<acp|tui|headless>` from the surface `main` sets via `set_surface`), it amends the trailer in —
   unless the commit already exists on a remote, which is never rewritten. Every child process it
   spawns (`spawn_shell`, the `git` helpers, and `hooks.rs`) sets `stdin` to null and never
   inherits it: in ACP mode sigit's stdin is the JSON-RPC pipe from the editor, so a command that
@@ -243,12 +252,32 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
   `handle_initialize` is what makes the rest of this reachable — without it Zed keeps the first
   root, drops the others, and shows "This agent doesn't currently support multi-root workspaces".
   The process still has one working directory, so the extra roots live in a
-  process-global here and `project_dirs()` returns cwd-first, extras after. Project-local
+  process-global here and `project_dirs()` returns cwd-first, extras after.
+  One process also serves every thread the editor has open, so that global
+  (with the cwd, the backend conversation, and the background-task owner in
+  `tools.rs`) always belongs to the *live* session: `main.rs` keeps a
+  `SessionState` per session id and `activate_session` parks the live one and
+  installs the requested one before any prompt or config change runs. Don't
+  read another session's roots from the global. Project-local
   discovery reads it: skills, slash commands, subagent types, and instruction files all scan
   every root. MCP is deliberately not on that list — `mcp::init` runs once at startup, before
   any session exists, so a second root's `.sigit/mcp.toml` has nobody to tell.
 - **`src/chat.rs`** — the Unix-only ratatui TUI. Loading-spinner phase then chat; uses
   `tokio::select!` to multiplex terminal events with streaming tokens.
+- **`src/headless.rs`** — non-interactive `sigit run` execution for scripts, CI, and Factory
+  clients. The legacy `-p` form reaches the same parser. Every new run gets a UUID session id;
+  `--resume <id>` restores that session through `session_store`, and `--output jsonl` emits a
+  structured session/delta/tool/result stream while logs stay on stderr. Headless permission
+  prompts collapse to denial unless the tool was pre-approved with `--allow-tool`.
+- **`src/session_store.rs`** — durable conversations: one JSON-lines history file per session at
+  `$SIGIT_CONFIG_DIR/sessions/<id>.jsonl`, written atomically, restorable into either backend.
+  Each save also writes a `<id>.meta.json` sidecar naming the session's `cwd` and the extra roots
+  of a multi-root project. That sidecar is what makes a thread *listable*: ACP's `session/list`
+  (advertised as `sessionCapabilities.list`, handled by `handle_list_sessions` in `main.rs` — the
+  editor's "Import Threads" picker) must report an absolute `cwd` per session and may filter on
+  it, so a session without one is skipped there while still reopening by id through
+  `session/load`. Sidecars are written at save time, not at session start, so a thread nobody
+  spoke in leaves nothing behind.
 - **`src/setup.rs`** — model cache location, local model discovery, selected-model persistence.
   Must run (`setup_shared_model_cache`) *before* anything touches `ChatEngine`/`hf-hub`, since
   those read env vars once at init.
@@ -322,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.10 → sigit_code-1.5.12}/Cargo.lock

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sigit-code
-Version: 1.5.10
+Version: 1.5.12
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -57,7 +57,8 @@ This installs a native `sigit` binary for your platform. You do not need a compi
 sigit
 ```
 
-That opens the local chat UI.
+That opens the local chat UI. Editors drive the same binary in ACP mode, which
+needs the `--acp` argument.
 
 ### Zed
 
@@ -68,7 +69,8 @@ siGit Code works as an [ACP-compatible](https://github.com/nicobailon/agent-clie
   "agent_servers": {
     "siGit Code": {
       "type": "custom",
-      "command": "/absolute/path/to/sigit"
+      "command": "/absolute/path/to/sigit",
+      "args": ["--acp"]
     }
   }
 }