kward 0.81.0 → 0.83.0

data/doc/security.md

@@ -57,8 +57,8 @@ Kward's built-in file tools normally resolve paths inside the active workspace.
 These protections reduce accidental edits. They do not contain the whole process:
 
 - With `sandbox.mode: off` (the default), `run_shell_command`, `!command`, `/capture`, `/shell`, and `/pty` run with your user permissions.
-- A non-off [command sandbox](sandboxing.md) restricts only model-requested `run_shell_command` workers and their descendants. It does not cover `!command`, `/capture`, `/shell`, or `/pty`.
-- External `/shell` commands, `!command`, and `/pty` forward child output directly to your terminal so interactive programs work. This bypasses transcript control-sequence sanitization; run only commands you trust with terminal access. `capture <command>` and `/capture <command>` sanitize their captured output.
+- A non-off [command sandbox](sandboxing.md) restricts only model-requested `run_shell_command` workers and their descendants. It does not cover `!command`, `/capture`, `/shell`, or `/pty`, including commands that the transient `?` shell assistant runs through the user's persistent `/shell` process.
+- External `/shell` commands, `!command`, and `/pty` receive an interactive PTY. Kward forwards a conservative set of line-oriented controls into the inline region, then grants full-terminal passthrough when a child emits screen-oriented or unknown controls. Full passthrough bypasses transcript control-sequence sanitization, so run only commands you trust with terminal access. `capture <command>` and `/capture <command>` sanitize their captured output.
 - Plugins, command hooks, and MCP servers are local processes with the same general operating-system access.
 - Read-before-edit applies to Kward's file tools, not to arbitrary shell commands or extension code.
 

data/doc/shell.md

@@ -4,6 +4,7 @@ Kward lets you run your own shell commands without leaving the interactive TUI.
 
 - **For one quick command, use `!command`.** It runs from the active workspace and returns you to the normal composer when it finishes.
 - **For a longer stretch of shell work, use `/shell`.** It keeps its directory, environment, aliases, and history between commands.
+- **To ask Kward for help from inside `/shell`, prefix the request with `?`.** It can inspect the latest shell output, run an explicitly requested state change, or prepare a command in the shell prompt for your confirmation.
 - **For bounded output in the transcript view, use `/capture <command>`.** Inside `/shell`, use `capture <command>` for the same kind of readable output while keeping the shell's current state.
 
 Ordinary `!command` input and external commands inside `/shell` receive an interactive PTY. Pagers, Vim, SSH, REPLs, password prompts, and other interactive tools therefore work without a `pty` prefix.
@@ -18,11 +19,11 @@ Prefix a command with `!` in the normal composer:
 !less README.md
 ```
 
-The command runs from the active workspace root and temporarily owns the terminal. When it exits, Kward restores the composer. Safe, line-oriented output from commands such as `ls` is mirrored into the transient transcript view so a repaint cannot hide it. Shell output is never added to the AI conversation or sent to the model.
+The command runs from the active workspace root and begins in an inline PTY region above a frozen composer. Line-oriented output, single-line carriage-return progress, and synchronized-output update brackets scroll the transcript area naturally while keyboard input belongs to the child process. If the child emits alternate-screen, clear-screen, absolute cursor, or unknown terminal controls, Kward conservatively hides the composer and switches permanently to full-terminal passthrough for the rest of that command. Pagers and full-screen applications therefore retain the complete terminal without relying on a command-name allowlist.
 
-The line-oriented Git commands `git fetch`, `git ls-remote`, `git push`, `git remote`, and `git status` keep the composer visible as a frozen display while they run. Keyboard input still belongs to the child process. Other commands use the full-terminal handoff so full-screen programs retain the complete terminal.
+When an inline command exits without reading input, safe output is mirrored into the transient transcript view so a repaint cannot hide it. Carriage-return and horizontal-cursor progress redraws are reduced to their final visible lines, while an unterminated synchronized-output update is closed before Kward redraws. If the child reads input, Kward retains only output captured before the first forwarded input byte; this prevents echoed passwords, OTPs, or other input from entering tab state. Output from one-off commands is never added to the AI conversation or sent to the model.
 
-Shell output can leave transient text in the transcript area. **After the command finishes, press Ctrl+L to redraw the durable conversation and clear that transient `!command` output.** While an interactive command is still running, keyboard input—including Ctrl+L and Kward's tab shortcuts—belongs to the child process.
+Shell output can leave transient text in the transcript area. **After the command finishes, press Ctrl+L to redraw the durable conversation and clear that transient `!command` output.** While an interactive command is still running, the composer remains frozen and keyboard input—including Ctrl+L and Kward's tab shortcuts—belongs to the child process.
 
 Configured `ekwsh.yml` aliases also work after `!`:
 
@@ -90,6 +91,29 @@ Leave shell mode with `exit`, `logout`, or Ctrl+D on an empty prompt.
 
 `cd` changes only the embedded shell's directory. It does not change Kward's workspace root or the directory used by the model's other tools.
 
+## Ask the shell agent
+
+While `/shell` is active, start a submitted line with `?` to ask the transient shell assistant:
+
+```text
+? why did the last command fail?
+? show me which process is listening on port 3000
+? prepare a command to find Ruby files changed today
+```
+
+The assistant receives the current shell directory, the last command, its exit status, and bounded output from that command. Output is sent to the model only because you explicitly asked with `?`; it is sanitized and bounded before being included, and shell-agent turns are not added to the normal session history.
+
+If you explicitly ask the assistant to change shell state, it can use the active shell session:
+
+```text
+? cd into test
+? set RAILS_ENV to test
+```
+
+For a suggestion or prepared command, the assistant uses `prepare_shell_command`. The command is placed in the shell composer but is not run until you press `Enter`. Running a command directly and preparing one are deliberately separate actions.
+
+The shell assistant cannot safely run commands that require terminal input. Ask it to prepare those commands instead. The local `/shell` session keeps one interactive shell process alive, so directory changes, variables, functions, aliases, and other shell state persist between commands. The one-off `!command` and `/capture` workflows remain separate. SSH remains available through the normal interactive PTY handoff, but shell-agent prompting resumes after that SSH session exits.
+
 ## Interactive and captured commands
 
 External commands inside `/shell` are interactive by default:
@@ -101,7 +125,7 @@ ruby
 ssh example.com
 ```
 
-Kward gives each command the terminal, forwards keyboard input, and restores the shell prompt when the command exits. It prints the submitted command but no PTY start message or exit-status summary. The line-oriented Git commands `git fetch`, `git ls-remote`, `git push`, `git remote`, and `git status` keep the shell prompt visible as a frozen display. Safe, line-oriented output from commands that did not read keyboard input is kept in the transient transcript view; full-screen and genuinely interactive output stays terminal-owned.
+Kward gives each command the terminal, forwards keyboard input, and restores the shell prompt when the command exits. Interactive commands inherit your normal pager configuration, so commands such as `git log` can open `less` in full-screen mode. Kward suppresses Git paging only for noninteractive shell-agent and `capture` executions. It prints the submitted command but no PTY start message or exit-status summary. The line-oriented Git commands `git fetch`, `git ls-remote`, `git push`, `git remote`, and `git status` keep the shell prompt visible as a frozen display. Safe, line-oriented output from commands that did not read keyboard input is kept in the transient transcript view; full-screen and genuinely interactive output stays terminal-owned.
 
 Use `capture` inside `/shell` when you want ordinary, readable output in Kward's transcript area instead of direct terminal control:
 
@@ -141,7 +165,7 @@ Each Kward tab owns its `/shell` state. Switching away and back restores that ta
 
 Shell commands use a separate, workspace-scoped history rather than the normal chat-prompt history. Configure its size with `history_limit` in `ekwsh.yml`.
 
-Kward's tab shortcuts work at the shell prompt and while a captured command is running. During an interactive command, the child owns every key; exit or interrupt it before switching Kward tabs.
+Kward's tab shortcuts work at the shell prompt and while a captured command is running. During an interactive command, the child owns every key; exit or interrupt it before switching Kward tabs. Bounded output from shell-agent `?` turns is also retained in the tab's transient runtime view, so it is restored when you switch away and back without being added to session history. Ctrl+L clears this transient shell and shell-agent output.
 
 ## Completion
 
@@ -179,7 +203,7 @@ When several candidates match, repeated Tab presses cycle through them and wrap
 
 ## Built-ins
 
-`ekwsh` handles a small set of commands itself so their state can persist:
+The persistent `/shell` process handles these commands in-session so their state can persist:
 
 | Built-in | What it does |
 | --- | --- |
@@ -232,12 +256,12 @@ aliases:
 
 | Setting | Default | What it does |
 | --- | --- | --- |
-| `shell` | `/bin/sh` | POSIX-compatible shell used with `-c`. It must be an absolute executable path. |
-| `timeout_seconds` | `300` | Maximum runtime for one captured command. |
-| `max_output_bytes` | `1048576` | Maximum output retained for one captured command. |
+| `shell` | `/bin/sh` | Absolute executable path for the persistent `/shell` process and interactive shell commands. |
+| `timeout_seconds` | `300` | Maximum runtime for one captured or shell-agent command. |
+| `max_output_bytes` | `1048576` | Maximum output retained for one captured or shell-agent command. |
 | `history_limit` | `1000` | Maximum shell-history entries per workspace. |
 
-Invalid or relative `shell` paths fall back to `/bin/sh`. These timeout and output limits apply only to `capture` inside `/shell`, not interactive commands or the separate `/capture` slash command.
+Invalid or relative `shell` paths fall back to `/bin/sh`. These timeout and output limits apply to `capture` inside `/shell` and shell-agent commands, not user-owned interactive commands or the separate `/capture` slash command.
 
 ### Environment
 
@@ -253,7 +277,7 @@ TERM=xterm-256color  # only when TERM is missing or dumb
 
 It does not force color. Set `FORCE_COLOR`, `CLICOLOR_FORCE`, or a command-specific option such as `--color=always` when needed.
 
-When rbenv is available, Kward adds its shims and bin directories to `PATH` and supplies `RBENV_ROOT` if it was missing. This lets `ruby`, `bundle`, and `./exe/kward` use the selected Ruby without sourcing shell startup files.
+When rbenv is available, Kward adds its shims and bin directories to `PATH` and supplies `RBENV_ROOT` if it was missing before starting `/shell`. The configured interactive shell may also load its normal startup files.
 
 ### Aliases
 
@@ -281,17 +305,17 @@ Aliases are intentionally simple: they do not expand recursively and are not she
 
 ## Terminal output and safety
 
-Interactive commands write directly to your terminal so full-screen tools can work. When a command does not read keyboard input and emits only line-oriented text plus safe color sequences, Kward mirrors that output into the transient transcript view after the command exits. Other interactive output is not sanitized and may contain terminal control sequences, so run only commands you trust with terminal access.
+Interactive commands write directly to your terminal so full-screen tools can work. When a command does not read keyboard input and emits only line-oriented text plus safe color sequences, Kward mirrors that output into the transient transcript view after the command exits. Other interactive output is not sanitized and may contain terminal control sequences, so run only commands you trust with terminal access. Safe bounded output is included in a shell-agent request only when you explicitly use `?`; it is never sent to the model for ordinary shell commands.
 
 Commands run with `capture` inside `/shell` preserve safe ANSI color and style sequences while removing cursor movement, clear-screen controls, title changes, alternate-screen controls, and similar sequences that could damage the TUI transcript.
 
 ## Limitations
 
-`ekwsh` manages shell-like state, but it is not a persistent login shell or terminal emulator:
+The local `/shell` session is persistent, but it is not a complete terminal emulator or a remote-shell protocol:
 
-- each external command runs separately through the configured shell,
-- there is no job control; a stopped child is terminated rather than leaving the terminal stranded,
-- shell functions do not persist and shell startup files are not sourced,
-- there is no login-shell readline integration,
+- the one-off `!command` and `/capture` workflows do not share `/shell` state,
+- shell state is held by the live process and is not serialized across Kward restarts,
+- a stopped or unresponsive command can still require Ctrl+C or shell-session cleanup,
 - full-screen terminal state is not retained after an interactive command exits,
-- safe line-oriented output may remain in the transient TUI transcript, but full-screen terminal state is not retained and no shell output becomes part of the AI conversation.
+- while an interactive SSH session owns the terminal, Kward cannot safely intercept `?` or provide remote cwd/completion context; shell-agent prompting resumes after SSH exits,
+- safe line-oriented output may remain in the transient TUI transcript; only bounded safe output from an explicit `?` request enters the transient shell-agent context and none of it is added to the normal session history.

data/doc/tabs.md

@@ -39,6 +39,8 @@ A normal session tab can be activated in a linked Git worktree after you have re
 
 ```text
 /tab worktree
+# or
+/worktree
 ```
 
 When enabled, Kward keeps the same tab and transcript but rebuilds its agent against a new worktree. The tab label includes the worktree branch. The worktree is created from `HEAD`, so Kward warns when the original workspace is dirty and leaves those existing changes in the original checkout; it does not copy them automatically. `/tab worktree activate` is an explicit alias for the same action.
@@ -98,6 +100,7 @@ Tabs keep the conversations separate, so context from one tab does not automatic
 | `/tab worktree merge` | Merge the current worktree branch into the branch checked out in its original workspace |
 | `/tab worktree merge abort` | Abort a conflicted worktree merge in the original workspace |
 | `/tab worktree remove` | Remove a clean linked worktree and keep its branch |
+| `/worktree …` | Alias for `/tab worktree …` on the active tab |
 | `/tab move left` | Move the current tab one slot left |
 | `/tab move right` | Move the current tab one slot right |
 | `/tab move <number>` | Move the current tab to a numbered position |

data/doc/usage.md

@@ -78,7 +78,7 @@ For several commands, enter the embedded Kward shell:
 /shell
 ```
 
-`/shell` opens `ekwsh`, a Kward-native command mode that preserves state such as the current directory, environment variables, and aliases between commands. External commands receive an interactive PTY by default, so `git log`, `less`, Vim, SSH, and REPLs work without a prefix. Use `capture <command>` inside `/shell` or `/capture <command>` from the normal composer for bounded, transcript-friendly output. See [Embedded shell](shell.md) for built-ins, completion, configuration, ANSI handling, PTY passthrough, and limitations.
+`/shell` opens `ekwsh`, a Kward-native command mode with one persistent local shell process. It preserves state such as the current directory, environment variables, functions, and aliases between commands. Prefix a line with `?` inside `/shell` to ask a transient shell assistant about the latest output, execute an explicit state change, or prepare a command without running it. External commands receive an interactive PTY by default, so `git log`, `less`, Vim, SSH, and REPLs work without a prefix. Use `capture <command>` inside `/shell` or `/capture <command>` from the normal composer for bounded, transcript-friendly output. See [Embedded shell](shell.md) for built-ins, completion, configuration, ANSI handling, PTY passthrough, and limitations.
 
 ## Shell commands
 
@@ -123,7 +123,7 @@ Slash commands run local actions in the current session. Most do not send a prom
 | `/git` | review uncommitted changes, stage files, and commit. |
 | `/diff` | open the file changes recorded in the current session. |
 | `/files` | browse project files in a nested tree and open them in the editor. |
-| `/shell` | run stateful workspace commands with interactive PTY support. |
+| `/shell` | run stateful workspace commands with interactive PTY support and ask the shell agent with `?`. |
 | `/capture <command>` | run a bounded one-shot command and retain its output in the transcript. |
 | `/pty <command>` | explicitly hand the terminal to an interactive command; retained for compatibility with existing workflows. |
 | `/settings` | configure models, accounts, memory, interface, tools, context, personalization, and logging. |
@@ -143,6 +143,7 @@ Slash commands run local actions in the current session. Most do not send a prom
 | `/tab worktree merge` | merge a clean worktree branch into the branch checked out in its original workspace. |
 | `/tab worktree merge abort` | abort a conflicted worktree merge in the original workspace. |
 | `/tab worktree remove` | remove a clean linked worktree while keeping its branch. |
+| `/worktree …` | alias for `/tab worktree …` on the active tab. |
 | `/session` | open the saved sessions picker or continue a previous session by path. |
 | `/resume` | alias for `/session`. |
 | `/session name <name>` | name or clear the current session. |

data/kward.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.files = Dir.chdir(__dir__) do
     `git ls-files -z`.split("\x0").reject do |file|
-      file.start_with?(".ruby-lsp/", "test/", "plan/") || [".gitignore", "AGENTS.md"].include?(file)
+      file.start_with?(".github/", ".ruby-lsp/", "script/", "test/", "plan/") || [".gitignore", "AGENTS.md"].include?(file)
     end
   end
   spec.bindir = "exe"

data/lib/kward/adaptive_pty_output_sink.rb

@@ -0,0 +1,183 @@
+require_relative "terminal_sequences"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Streams a conservative subset of PTY output into Kward's inline terminal
+  # region and permanently switches to exclusive passthrough before forwarding
+  # screen-oriented or unknown terminal controls.
+  class AdaptivePtyOutputSink
+    MAX_SEQUENCE_BYTES = 4096
+    SAFE_CONTROLS = [0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d].freeze
+    TERMINAL_STRING_INTRODUCERS = [0x5d, 0x50, 0x5e, 0x5f, 0x58].freeze
+
+    attr_reader :captured_output
+
+    def initialize(output:, on_exclusive:, max_capture_bytes: nil)
+      @output = output
+      @on_exclusive = on_exclusive
+      @max_capture_bytes = max_capture_bytes
+      @captured_output = max_capture_bytes ? +"".b : nil
+      @capture_open = true
+      @truncated = false
+      @mode = :inline
+      @sequence = +"".b
+      @synchronized_output = false
+    end
+
+    def write(chunk)
+      value = chunk.to_s.b
+      capture(value)
+      return @output.write(value) if exclusive?
+
+      write_inline(value)
+    end
+
+    def flush
+      @output.flush if @output.respond_to?(:flush)
+    end
+
+    def finish
+      switch_to_exclusive(@sequence) unless @sequence.empty? || exclusive?
+      end_synchronized_output if inline?
+      flush
+    end
+
+    def input_forwarded
+      @capture_open = false
+    end
+
+    def inline?
+      @mode == :inline
+    end
+
+    def transcript_safe?
+      inline? && @sequence.empty?
+    end
+
+    def pre_input_capture_only?
+      true
+    end
+
+    def truncated?
+      @truncated
+    end
+
+    private
+
+    def exclusive?
+      @mode == :exclusive
+    end
+
+    def write_inline(value)
+      safe_output = +"".b
+      index = 0
+      while index < value.bytesize
+        byte = value.getbyte(index)
+        if @sequence.empty?
+          if byte == 0x1b
+            @sequence << byte
+          elsif byte >= 0x20 || SAFE_CONTROLS.include?(byte)
+            safe_output << byte
+          else
+            flush_safe_output(safe_output)
+            switch_to_exclusive(value.byteslice(index..))
+            return
+          end
+        else
+          @sequence << byte
+          status = sequence_status
+          if status == :safe
+            track_safe_sequence(@sequence)
+            safe_output << @sequence
+            @sequence.clear
+          elsif status == :exclusive
+            flush_safe_output(safe_output)
+            remainder = value.byteslice((index + 1)..).to_s.b
+            switch_to_exclusive(@sequence + remainder)
+            @sequence.clear
+            return
+          end
+        end
+        index += 1
+      end
+      flush_safe_output(safe_output)
+    end
+
+    def sequence_status
+      return :exclusive if @sequence.bytesize > MAX_SEQUENCE_BYTES
+      return :pending if @sequence.bytesize == 1
+
+      second = @sequence.getbyte(1)
+      return csi_status if second == "[".ord
+      return :exclusive if TERMINAL_STRING_INTRODUCERS.include?(second)
+      return escape_intermediate_status if second.between?(0x20, 0x2f)
+
+      :exclusive
+    end
+
+    def csi_status
+      return :pending if @sequence.bytesize == 2
+
+      byte = @sequence.getbyte(-1)
+      return safe_csi? ? :safe : :exclusive if byte.between?(0x40, 0x7e)
+      return :pending if byte.between?(0x20, 0x3f)
+
+      :exclusive
+    end
+
+    def escape_intermediate_status
+      byte = @sequence.getbyte(-1)
+      return :pending if byte.between?(0x20, 0x2f)
+
+      :exclusive
+    end
+
+    def safe_csi?
+      value = @sequence
+      value.match?(/\A\e\[[0-9:;]*m\z/) ||
+        value.match?(/\A\e\[[0-2]?K\z/) ||
+        value.match?(/\A\e\[[0-9;]*[CDG`]\z/) ||
+        value.match?(/\A\e\[\?25[hl]\z/) ||
+        value.match?(/\A\e\[\?(?:2004|2026)[hl]\z/) ||
+        value.match?(/\A\e\[[0-9;]* q\z/)
+    end
+
+    def track_safe_sequence(sequence)
+      @synchronized_output = true if sequence == TerminalSequences::SYNCHRONIZED_OUTPUT_ENABLE
+      @synchronized_output = false if sequence == TerminalSequences::SYNCHRONIZED_OUTPUT_DISABLE
+    end
+
+    def end_synchronized_output
+      return unless @synchronized_output
+
+      @output.write(TerminalSequences::SYNCHRONIZED_OUTPUT_DISABLE)
+      @synchronized_output = false
+    end
+
+    def flush_safe_output(value)
+      return if value.empty?
+
+      @output.write(value)
+      value.clear
+    end
+
+    def switch_to_exclusive(value)
+      end_synchronized_output
+      @on_exclusive.call
+      @mode = :exclusive
+      @output.write(value) unless value.empty?
+    end
+
+    def capture(value)
+      return unless @captured_output && @capture_open
+
+      remaining = @max_capture_bytes - @captured_output.bytesize
+      if value.bytesize > remaining
+        @captured_output << value.byteslice(0, remaining) if remaining.positive?
+        @truncated = true
+      else
+        @captured_output << value
+      end
+    end
+  end
+end

data/lib/kward/agent.rb

@@ -84,6 +84,7 @@ module Kward
       end
       loop do
         cancellation&.raise_if_cancelled!
+        auto_compact_if_needed
         begin
           message = chat(on_reasoning_delta: on_reasoning_delta, on_retry: on_retry, cancellation: cancellation, steering: steering, options: options, tool_registry: tool_registry) do |event|
             yield event if block_given?

data/lib/kward/auth/anthropic_oauth.rb

@@ -17,7 +17,7 @@ module Kward
     DEFAULT_PORT = 53_692
     CALLBACK_PATH = "/callback"
     DEFAULT_CLIENT_ID = Base64.decode64("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl")
-    SCOPE = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload"
+    SCOPE = "user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload"
 
     attr_reader :auth_path
 
@@ -60,7 +60,7 @@ module Kward
       end
       raise "Missing authorization code" if code.to_s.empty?
 
-      complete_login_flow(code: code, redirect_uri: redirect_uri, code_verifier: pkce[:verifier])
+      complete_login_flow(code: code, redirect_uri: redirect_uri, code_verifier: pkce[:verifier], state: state)
       auth_path
     ensure
       server&.close unless server&.closed?
@@ -68,7 +68,6 @@ module Kward
 
     def authorization_url(redirect_uri:, code_challenge:, state:)
       query = URI.encode_www_form(
-        code: "true",
         client_id: client_id,
         response_type: "code",
         redirect_uri: redirect_uri,
@@ -98,8 +97,8 @@ module Kward
       wait_for_callback(server, expected_state: expected_state, timeout_seconds: timeout_seconds)
     end
 
-    def complete_login_flow(code:, redirect_uri:, code_verifier:)
-      tokens = exchange_code_for_tokens(code: code, redirect_uri: redirect_uri, code_verifier: code_verifier)
+    def complete_login_flow(code:, redirect_uri:, code_verifier:, state:)
+      tokens = exchange_code_for_tokens(code: code, redirect_uri: redirect_uri, code_verifier: code_verifier, state: state)
       save_auth(tokens: tokens)
       tokens
     end
@@ -192,13 +191,14 @@ module Kward
       oauth_callback_server(port_env: "KWARD_ANTHROPIC_OAUTH_PORT", default_port: DEFAULT_PORT)
     end
 
-    def exchange_code_for_tokens(code:, redirect_uri:, code_verifier:)
+    def exchange_code_for_tokens(code:, redirect_uri:, code_verifier:, state:)
       response = post_json(TOKEN_URL,
         grant_type: "authorization_code",
         client_id: client_id,
         code: code,
         redirect_uri: redirect_uri,
-        code_verifier: code_verifier)
+        code_verifier: code_verifier,
+        state: state)
       parse_successful_json(response, "Anthropic OAuth token exchange")
     end
 

data/lib/kward/cli/git.rb

@@ -30,12 +30,16 @@ module Kward
           status = result.is_a?(Hash) && result.key?(:status_lines) ? result[:status_lines] : result
           result
         end
-        return if message.nil?
+        if message.nil?
+          refresh_composer_status
+          return
+        end
 
         result = run_busy_local_command_and_requeue(activity: "committing") do
           git_commit(git_root, message)
         end
         print_git_commit_result(result)
+        refresh_composer_status
       ensure
         @git_hook_conversation = previous_git_hook_conversation
       end

data/lib/kward/cli/interactive_turn.rb

@@ -6,9 +6,68 @@ module Kward
     module InteractiveTurn
       private
 
-      def run_interactive_turn(agent, input, display_input: nil)
-        prepare_memory_context(agent.conversation, input) if agent.respond_to?(:conversation)
-        return run_blocking_interactive_turn(agent, input, display_input: display_input) unless prompt_interface?
+      def run_editor_prompt_turn(action, agent)
+        unless agent.respond_to?(:tool_registry) && agent.tool_registry.respond_to?(:for_editor_prompt)
+          runtime_output("Editor prompts are unavailable in this tab.")
+          return []
+        end
+        unless @prompt.respond_to?(:editor_prompt_context)
+          runtime_output("Editor prompts are unavailable in this prompt.")
+          return []
+        end
+
+        context = @prompt.editor_prompt_context
+        unless context
+          runtime_output("Open a Modern or Vibe editor buffer before prompting the agent.")
+          return []
+        end
+
+        unless @prompt.suspend_editor_for_agent
+          runtime_output("The editor is busy.")
+          return []
+        end
+
+        session = EditorPromptSession.new(context)
+        registry = agent.tool_registry.for_editor_prompt(session)
+        editor_agent = build_editor_prompt_agent(agent, context, registry)
+        instruction = action[:instruction] || action["instruction"]
+        run_interactive_turn(
+          editor_agent,
+          EditorPrompt.input(instruction, context),
+          tool_registry: registry,
+          editor_prompt_session: session,
+          suppress_transcript: true
+        )
+      rescue StandardError => e
+        @prompt.resume_editor_for_agent(status: "Agent request failed") if @prompt.respond_to?(:resume_editor_for_agent)
+        runtime_output("Error: #{e.message}")
+        []
+      end
+
+      def build_editor_prompt_agent(active_agent, context, registry)
+        active_conversation = active_agent.conversation
+        config = safely_read_config.to_h
+        provider = active_conversation.provider || current_model_provider
+        model = ConfigFiles.editor_agent_model(config) || active_conversation.model || current_model_id
+        reasoning = ConfigFiles.editor_agent_reasoning_effort(config) || active_conversation.reasoning_effort || current_reasoning_effort
+        conversation = Conversation.new(
+          system_message: EditorPrompt.system_message,
+          workspace_root: context[:workspace_root] || active_conversation.workspace_root,
+          provider: provider,
+          model: model,
+          reasoning_effort: reasoning
+        )
+        Agent.new(
+          client: @client,
+          tool_registry: registry,
+          conversation: conversation,
+          warning_sink: ConfigFiles.warning_sink
+        )
+      end
+
+      def run_interactive_turn(agent, input, display_input: nil, tool_registry: nil, editor_prompt_session: nil, suppress_transcript: false, busy_label: "You>", on_complete: nil)
+        prepare_memory_context(agent.conversation, input) if agent.respond_to?(:conversation) && !suppress_transcript
+        return run_blocking_interactive_turn(agent, input, display_input: display_input, tool_registry: tool_registry, suppress_transcript: suppress_transcript, on_complete: on_complete) unless prompt_interface?
 
         queued_inputs = []
         cancellation = Cancellation.new
@@ -25,11 +84,11 @@ module Kward
         markdown_chunks = []
         answer = nil
         error = nil
-        @prompt.begin_busy_input("You>") if @prompt.respond_to?(:begin_busy_input)
-        print_user_transcript(input, display_input: display_input)
+        @prompt.begin_busy_input(busy_label) if @prompt.respond_to?(:begin_busy_input)
+        print_user_transcript(input, display_input: display_input) unless suppress_transcript
 
         worker = Thread.new do
-          options = agent_display_options(display_input)
+          options = agent_display_options(display_input, tool_registry: tool_registry)
           options[:cancellation] = cancellation
           options[:steering] = steering if steering
           answer = agent.ask(input, **options) do |event|
@@ -52,7 +111,7 @@ module Kward
             cancellation.cancel!
             worker.raise(Cancellation::CancelledError, "cancelled") if worker.alive?
           end
-          if busy_replacement_agent?
+          if busy_replacement_agent? || suppress_transcript
             discard_interactive_events(event_queue, markdown_chunks, stream_state)
           else
             drain_interactive_events(event_queue, markdown_chunks, stream_state, agent)
@@ -64,19 +123,39 @@ module Kward
           error ||= e
         end
         drain_busy_input(queued_inputs, nil) unless cancelled
-        if busy_replacement_agent?
+        if busy_replacement_agent? || suppress_transcript
           discard_interactive_events(event_queue, markdown_chunks, stream_state, force: true)
         else
           drain_interactive_events(event_queue, markdown_chunks, stream_state, agent, force: true)
         end
+        completed = !cancelled && !busy_replacement_agent? && !error
+        on_complete&.call(successful: completed, cancelled: cancelled, error: error, answer: answer)
         raise error if error && !error.is_a?(Cancellation::CancelledError) && !busy_replacement_agent?
 
-        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless cancelled || busy_replacement_agent? || stream_state[:streamed] || answer.to_s.empty?
-        persist_memory_state(agent.conversation) if agent.respond_to?(:conversation)
-        auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation) && queued_inputs.empty? && !cancelled
+        @prompt.commit_editor_prompt(editor_prompt_session) if editor_prompt_session && completed
+        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless suppress_transcript || cancelled || busy_replacement_agent? || stream_state[:streamed] || answer.to_s.empty?
+        persist_memory_state(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript
+        auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript && queued_inputs.empty? && !cancelled
         queued_inputs
       ensure
         @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
+        if editor_prompt_session && @prompt.respond_to?(:resume_editor_for_agent)
+          status = if cancelled
+            "Agent request cancelled"
+          elsif error
+            "Agent request failed"
+          elsif editor_prompt_session && !editor_prompt_session.changed? && !answer.to_s.strip.empty?
+            editor_prompt_answer_status(answer)
+          end
+          @prompt.resume_editor_for_agent(status: status)
+        end
+      end
+
+      def editor_prompt_answer_status(answer)
+        text = answer.to_s.gsub(/\s+/, " ").strip
+        text = text[0, 120].to_s
+        text += "…" if answer.to_s.gsub(/\s+/, " ").strip.length > text.length
+        "Agent: #{text}"
       end
 
       def drain_interactive_events(event_queue, markdown_chunks, stream_state, agent = nil, force: false)
@@ -261,21 +340,24 @@ module Kward
         ModelInfo.reasoning_supported?(current_model_provider, model)
       end
 
-      def run_blocking_interactive_turn(agent, input, display_input: nil)
+      def run_blocking_interactive_turn(agent, input, display_input: nil, tool_registry: nil, suppress_transcript: false, on_complete: nil)
         streamed = false
         markdown_chunks = []
-        answer = agent.ask(input, **agent_display_options(display_input)) do |event|
-          streamed = true if render_blocking_turn_event(event, markdown_chunks, tool_line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
+        answer = agent.ask(input, **agent_display_options(display_input, tool_registry: tool_registry)) do |event|
+          streamed = true if !suppress_transcript && render_blocking_turn_event(event, markdown_chunks, tool_line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
         end
         flush_markdown_deltas(markdown_chunks) if streamed
-        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless streamed || answer.to_s.empty?
-        persist_memory_state(agent.conversation) if agent.respond_to?(:conversation)
-        auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation)
+        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless suppress_transcript || streamed || answer.to_s.empty?
+        persist_memory_state(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript
+        auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript
+        on_complete&.call(successful: true, cancelled: false, error: nil, answer: answer)
         []
       end
 
-      def agent_display_options(display_input)
-        display_input.nil? ? {} : { display_input: display_input }
+      def agent_display_options(display_input, tool_registry: nil)
+        options = display_input.nil? ? {} : { display_input: display_input }
+        options[:tool_registry] = tool_registry if tool_registry
+        options
       end
 
     end