kward 0.81.0 → 0.82.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2033aa9b07468c6668842a3b0ba51ef73cb0c1c58db95927c1159668129e345
-  data.tar.gz: 0f7c86a02ccf5e76f01adf3a8d654b3bd559ef27c93f6479dfd6724401427435
+  metadata.gz: e4e40d786a99770eef30a7eb7fec41470d927f9d889160d1c6db9f8fd1ebec39
+  data.tar.gz: 1cfaf680bf9b5ef313e0a0f71a3fb33ea394eb7bc2f5d19c5bfee4c38898ac49
 SHA512:
-  metadata.gz: 934c63dbcde19c9eba5dbdfb843a5cbb82a873d73371746d3db19c5698c27aa53ecef3820bb7099a928e077f05d04178190e4ddafef3ff8ed9e82aa7233c2d75
-  data.tar.gz: 05ac5a0a3a695f9b49c56059915e642511c85f0dcaa68e406f0b470763b589497a92950416a0f7eddb2a69b304c9b7f6bcef3bcbea49cedd8032b06871c3cfba
+  metadata.gz: efe8e4a599791fee93d0329c7d0ec4e87c9d45c9ad9f99165d9172d44410ccc83de8014802cc76481d37952e89427b80cac1022a2f7fc17d0bd3c05356d44391
+  data.tar.gz: 9b1ad11cfd582d78d4834cf5b6f168ca8e2f987abe99804678d5e58c2e3000fcff6ebbf30448a71aa1f0ca7a94e9e9585be7b0643d6c88e3ed931e3ab6f3eada

data/CHANGELOG.md

@@ -4,6 +4,35 @@ All notable changes to Kward will be documented in this file.
 
 ## [Unreleased]
 
+## [0.82.0] - 2026-08-23
+
+### Added
+
+- Added `script/release` for validated, one-command release preparation from an argument or standard input, including changelog/version updates, preflight checks, an annotated tag, and an atomic push.
+- Added a tag-triggered GitHub Actions release workflow using RubyGems trusted publishing, published-artifact checksum verification, changelog-based GitHub Releases, and safe reruns after partial publication.
+- Added `+` and `-` controls for resizing inline `/files` image previews within the available overlay space.
+- Added inline read-only previews for PNG, JPEG, GIF, and WebP files opened from `/files` in terminals that support Kitty or iTerm2 image sequences, with local conversion for Kitty-compatible terminals when needed.
+
+### Changed
+
+- Excluded GitHub workflow and local release-script files from packaged gems and added explicit release metadata and package-content checks.
+- Changed interactive PTY handoff to render conservative line/progress output above a frozen composer, with a permanent switch to exclusive full-terminal passthrough when the child emits screen-oriented or unknown controls.
+- Kept safe, normalized shell output as explicit tab-local transient state so completed `/shell` and `!command` output can be reconstructed after tab switches without entering session history or model context.
+
+### Fixed
+
+- Made the test environment explicitly disable terminal color and made unified diff-viewer tests select that mode explicitly, keeping release preflight assertions deterministic across terminal capabilities and widths.
+- Kept `/files` image previews bounded within a fully cleared, bordered file-list overlay above the visible composer and preserved their aspect ratio in Kitty-compatible terminals.
+- Fixed inline image protocol detection and viewer handoff for Ghostty and other Kitty-compatible terminals by retrying inconclusive probes, honoring recognized Kitty hints, suppressing Kitty acknowledgements, and using valid, chunked graphics sequences.
+- Kept synchronized-output updates such as Homebrew downloads in the inline PTY region instead of resetting the cursor through an unnecessary exclusive handoff.
+- Retained the final visible state of carriage-return and horizontal-cursor progress output from commands such as `git push` and Homebrew when reconstructing the transcript after PTY handback.
+- Cached rebuildable session-list summaries so opening `/session` no longer reparses every unchanged conversation log, while retaining automatic fallback for existing, changed, or corrupt session data.
+- Refreshed composer status immediately after model runtime changes and `/git` returns, so selected model details and Git dirty-state color do not remain stale until another input.
+- Kept echoed passwords, OTPs, and other child input out of transient tab state by stopping safe PTY output retention before the first forwarded input byte.
+- Reconstructed safe transient shell output as part of the PTY ownership handback frame, avoiding an extra clear and redraw after commands such as `ls`.
+- Preserved the active `/shell` prompt and composer when Ctrl+L clears transient shell output, and avoided a redundant preliminary redraw.
+- Reconstructed the complete Kward screen after interactive PTY handoff, including failure paths, instead of relying on the child process cursor position.
+
 ## [0.81.0] - 2026-08-20
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kward (0.81.0)
+    kward (0.82.0)
       base64
       nokogiri
       tiktoken_ruby
@@ -146,7 +146,7 @@ CHECKSUMS
   html-proofer (5.2.1) sha256=fdd958a7cbf9c3255fb96fe7cfc4e611f64e2706e469488a3326309ad007d2fd
   io-event (1.16.2) sha256=9f9cb0a96ea5c3850a672606c65f27bc96d7621399ef6196acbfe2be0cd1279c
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
-  kward (0.81.0)
+  kward (0.82.0)
   logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
   metrics (0.15.0) sha256=61ded5bac95118e995b1bc9ed4a5f19bc9814928a312a85b200abbdac9039072
   minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1

data/README.md

@@ -92,7 +92,7 @@ Extend and integrate:
 - [Plugins](doc/plugins.md): trusted Ruby plugins for commands, footer UI, prompt context, transcript events, and RPC clients.
 - [Lifecycle hooks](doc/lifecycle-hooks.md): deterministic runtime hooks for policy, approvals, automation, and command-hook integrations.
 - [RPC protocol](doc/rpc.md): JSON-RPC backend mode for trusted local UI clients.
-- [Releasing](doc/releasing.md): release checklist for RubyGems publishing.
+- [Releasing](doc/releasing.md): prepare a version and publish it through RubyGems and GitHub Releases.
 
 Reference guides:
 

data/Rakefile

@@ -1,5 +1,7 @@
+require "bundler/gem_tasks"
 require "fileutils"
 require "html-proofer"
+require "open3"
 require "rdoc/task"
 require "rubygems/package"
 require "webrick"
@@ -33,6 +35,36 @@ def packaged_gem_files(gem_name)
   gem.spec.files.sort
 end
 
+def verify_release_metadata
+  version = Kward::VERSION
+  tag = "v#{version}"
+  changelog = File.read("CHANGELOG.md")
+  abort("CHANGELOG.md is missing a [#{version}] release heading") unless changelog.match?(/^## \[#{Regexp.escape(version)}\] - \d{4}-\d{2}-\d{2}$/)
+
+  if ENV["GITHUB_REF_TYPE"] == "tag" && ENV["GITHUB_REF_NAME"] != tag
+    abort("GitHub tag #{ENV["GITHUB_REF_NAME"]} does not match gem version #{version}")
+  end
+
+  tag_commit, tag_status = Open3.capture2e("git", "rev-parse", "--verify", "#{tag}^{commit}")
+  return unless tag_status.success?
+
+  head_commit = `git rev-parse HEAD`.strip
+  abort("Tag #{tag} does not point at HEAD") unless tag_commit.strip == head_commit
+end
+
+def verify_packaged_gem(gem_name)
+  files = packaged_gem_files(gem_name)
+  required = ["exe/kward", "lib/kward/version.rb"]
+  missing = required - files
+  abort("Packaged gem is missing: #{missing.join(", ")}") unless missing.empty?
+
+  forbidden_prefixes = [".github/", "script/", "test/", "plan/"]
+  forbidden = files.select { |file| forbidden_prefixes.any? { |prefix| file.start_with?(prefix) } }
+  abort("Packaged gem includes development files: #{forbidden.join(", ")}") unless forbidden.empty?
+
+  files
+end
+
 def rewrite_yard_markdown_links
   guide_names = Dir.glob("doc/*.md").map { |path| File.basename(path, ".md") }
 
@@ -75,15 +107,23 @@ YARD::Rake::YardocTask.new do |yard|
 end
 
 namespace :release do
+  desc "Verify the version, changelog, and release tag agree"
+  task :verify do
+    verify_release_metadata
+  end
+
   desc "Run release checks and build a local gem"
-  task preflight: [:test, "docs:check"] do
-    gem_name = "kward-#{Kward::VERSION}.gem"
+  task preflight: ["release:verify", :test, "docs:check"] do
+    gem_name = File.join("pkg", "kward-#{Kward::VERSION}.gem")
     FileUtils.rm_f(gem_name)
-    sh "gem", "build", "kward.gemspec"
-    puts packaged_gem_files(gem_name)
+    Rake::Task["build"].invoke
+    puts verify_packaged_gem(gem_name)
   end
 end
 
+Rake::Task["release:source_control_push"].enhance(["release:verify"])
+Rake::Task["release:rubygem_push"].enhance(["release:verify"])
+
 namespace :docs do
   desc "Serve the built YARD documentation site locally and rebuild on changes"
   task serve: :build do

data/doc/composer.md

@@ -186,7 +186,7 @@ Example:
 
 If the cursor is at the start of an otherwise empty draft, Backspace removes the most recently added pending attachment. Submitting the draft clears its pending attachments.
 
-The active model must support image input. iTerm2 and Kitty-compatible terminals can render submitted images inline; other terminals still show attachment badges and send the image to the model without an inline preview.
+The active model must support image input. iTerm2 and Kitty-compatible terminals can render submitted images inline; Kward uses active Kitty capability detection when running on a real TTY and falls back to conservative terminal hints otherwise. Other terminals still show attachment badges and send the image to the model without an inline preview.
 
 ## Understand composer status
 
@@ -213,4 +213,4 @@ If rendering becomes corrupted after resize or after an external program writes
 
 You can also press `Ctrl+L`; it rebuilds the durable current-tab view without deleting the conversation transcript, removing transient shell output. If a shortcut never reaches Kward, prefer its slash-command equivalent or change `composer.tab_keybindings` in `/settings`.
 
-External commands inside `/shell` and one-shot `!command` input receive an interactive PTY by default, so full-screen programs such as Vim or `less` temporarily own the terminal. Use `capture <command>` inside `/shell` or `/capture <command>` from the normal composer when output should remain in Kward's transcript instead.
+External commands inside `/shell` and one-shot `!command` input receive an interactive PTY by default. They begin inline above a frozen composer, then switch to full-terminal passthrough if they emit screen-oriented or unknown terminal controls; full-screen programs such as Vim or `less` can therefore temporarily own the terminal. Use `capture <command>` inside `/shell` or `/capture <command>` from the normal composer for bounded, sanitized transcript output.

data/doc/files.md

@@ -12,9 +12,9 @@ From an interactive Kward session, run:
 /files
 ```
 
-Kward opens the project file browser. Use the arrow keys or `j`/`k` to move through the tree, then press `Enter` on a file to open it in the integrated editor.
+Kward opens the project file browser. Use the arrow keys or `j`/`k` to move through the tree, then press `Enter` on a file to open it in the integrated editor. Supported images (PNG, JPEG, GIF, and WebP) open as read-only inline previews when the terminal supports Kitty or iTerm2 image sequences.
 
-When you quit the editor, Kward returns to the file browser at the same position so you can keep browsing nearby files.
+When you quit the editor or close an image preview, Kward returns to the file browser at the same position so you can keep browsing nearby files.
 
 ## What appears in the browser
 
@@ -40,6 +40,8 @@ Outside Git, Kward scans the workspace directory and skips common noisy director
 | `/` | Start search |
 | `Backspace` | Delete the last search character |
 | `Esc` | Leave search; press again to close the browser |
+| `Q` | Close an image preview |
+| `+` / `-` | Zoom an image preview in / out |
 | `@` | Insert the selected file as an `@path` mention |
 
 Directories use `▸` and `▾` markers to show collapsed and expanded state. Files are shown under their containing directory with indentation. File-type icons are off by default; users with a compatible Nerd Font can enable them under Interface in `/settings`. See [Configuration](configuration.md#project-browser-icons).
@@ -92,6 +94,10 @@ Kward remembers the expanded folders and selected path for each workspace. The n
 
 Search itself is temporary. Closing search returns to the normal tree, and closing the browser leaves your chat session intact.
 
+## Image previews
+
+Image previews are read-only and replace the file-list overlay while leaving the prompt composer and tabs visible. Press `+` or `-` to make the image larger or smaller within the available overlay space. Press `Esc` or `Q` to return to `/files`. Kward probes Kitty-compatible terminals when it has a real interactive TTY, uses recognized terminal identity hints when probing is inconclusive, and retries transient detection failures. Terminals without reachable Kitty or iTerm2 inline-image support keep the selection in the browser and show a status message instead of opening binary data in the text editor. Kitty-compatible terminals use PNG data; JPEG, GIF, and WebP previews require an available local image converter.
+
 ## Notes and limitations
 
 - `/files` is only available in the interactive prompt.

data/doc/releasing.md

@@ -1,74 +1,107 @@
 # Releasing Kward
 
-## Before you begin
+Kward releases are prepared locally and published by GitHub Actions. The local command updates the version and changelog, runs every release check, creates the release commit and annotated tag, then pushes both atomically. The tag-triggered workflow publishes the gem to RubyGems.org and creates a GitHub Release with the same gem attached.
 
-Kward requires Ruby >= 3.4 (`spec.required_ruby_version` in `kward.gemspec`). If you develop with a newer Ruby, verify tests pass against the minimum supported version before releasing.
+## One-time setup
 
-## Prepare the release
+Kward publishes through [RubyGems trusted publishing](https://guides.rubygems.org/trusted-publishing/), so the repository does not need a long-lived RubyGems API key.
 
-Before publishing:
+Before the first automated release:
 
-1. Update `CHANGELOG.md` for the version. Move `[Unreleased]` entries under a new version heading.
-2. Update `Kward::VERSION` in `lib/kward/version.rb`.
-3. Run the release preflight:
+1. In the GitHub repository, create an Actions environment named `release`. Add required reviewers if releases should have a manual approval gate.
+2. On the RubyGems.org page for the `kward` gem, add a trusted publisher with:
+   - Repository owner: `kaiwood`
+   - Repository name: `kward`
+   - Workflow filename: `release.yml`
+   - Environment: `release`
+3. Confirm GitHub Actions can write repository contents. The release job requests only `contents: write` for the GitHub Release and `id-token: write` for RubyGems OIDC authentication.
 
-   ```bash
-   bundle exec rake release:preflight
-   ```
+GitHub Packages is intentionally not used. RubyGems.org remains the canonical package registry; the built `.gem` is also attached to each GitHub Release.
 
-   This runs the full test suite, builds and checks the generated docs, builds a local gem, and prints the packaged file list for review.
+## Prepare a release
 
-4. Run focused tests for any areas you changed during the release prep itself (docs, config, etc.):
+Keep notable changes under the appropriate `Added`, `Changed`, `Fixed`, or `Removed` heading in the `[Unreleased]` section of `CHANGELOG.md`. Do not add the version heading by hand.
 
-   ```bash
-   ruby -Itest test/test_cli.rb
-   ```
+Before releasing, make sure `main` is clean, pushed, and synchronized with `origin/main`. Then run:
 
-5. Preview docs locally if you changed documentation or public APIs:
+```bash
+script/release 0.82.0
+```
+
+The version can also come from standard input:
+
+```bash
+printf '0.82.0\n' | script/release
+```
+
+The command fails closed unless:
 
-   ```bash
-   bundle exec rake docs:serve
-   ```
+- The version is a valid RubyGems version newer than `Kward::VERSION`.
+- The working tree is clean and checked out on `main`.
+- Local `main` exactly matches `origin/main`.
+- The tag does not exist locally or on GitHub.
+- RubyGems.org does not already contain the version.
+- `[Unreleased]` contains at least one changelog entry.
 
-   The preview builds `_yardoc/`, serves it with WEBrick, and rebuilds in a fresh process when documentation sources, library code, or templates change. Refresh your browser after rebuilds.
+If validation succeeds, it:
 
-6. If you want to run the documentation check separately:
+1. Updates `Kward::VERSION` in `lib/kward/version.rb`.
+2. Refreshes `Gemfile.lock` with `bundle lock --local`.
+3. Moves the unreleased changelog entries under a dated version heading.
+4. Runs `bundle exec rake release:preflight`.
+5. Commits the three release files as `Release v0.82.0`.
+6. Creates an annotated `v0.82.0` tag.
+7. Atomically pushes `main` and the tag to `origin`.
 
-   ```bash
-   bundle exec rake docs:build
-   bundle exec rake docs:check
-   ```
+If preparation fails before the commit, the command restores the version, lockfile, and changelog. If tagging or pushing fails after the commit, it leaves the release commit in place and prints the failed command; inspect the repository before retrying rather than creating another release commit.
 
-   `docs:check` validates generated internal links, images, and scripts. Pushes to `main` deploy the generated YARD site to GitHub Pages. You can also run `bundle exec rake rdoc` to generate a separate RDoc site as a sanity check, but it is not deployed.
+## What the release workflow does
 
-7. Inspect the packaged files printed by `release:preflight` and confirm no local config, sessions, logs, or secrets are included. The gemspec uses `git ls-files` and excludes `test/`, `plan/`, `.ruby-lsp/`, `.gitignore`, and `AGENTS.md`.
+A pushed `v*` tag starts `.github/workflows/release.yml`. The workflow:
 
-8. Install the built gem locally and smoke test the `kward` executable in a clean workspace.
+1. Checks that the tag, gem version, and changelog heading agree.
+2. Runs the full test suite and generated-documentation checks against Ruby 3.4.
+3. Builds the gem and verifies its packaged files.
+4. Publishes through RubyGems trusted publishing.
+5. Verifies the local gem checksum against the artifact served by RubyGems.org.
+6. Creates `Kward VERSION` as a GitHub Release using that version's changelog section and attaches the verified gem.
 
-## Tag and publish
+The publishing job uses the protected `release` environment. If RubyGems.org already has the version after a partially completed workflow, a rerun rebuilds the gem and verifies that it exactly matches the published checksum before continuing. For an existing GitHub Release, the workflow downloads and compares the gem, uploads it when missing, and publishes an unfinished draft. This makes normal workflow reruns safe without silently replacing mismatched artifacts.
 
-Commit the version bump and create a Git tag:
+Follow the run from the repository's **Actions → Release** page. Installation can be checked after publication with:
 
 ```bash
-git commit -am "Bump to VERSION"
-git tag vVERSION
-git push && git push --tags
+gem install kward --version 0.82.0
+kward --version
 ```
 
-Publish the built gem from the release checkout:
+## Run checks without releasing
+
+After updating to an unreleased version, run the complete preflight directly with:
+
+```bash
+bundle exec rake release:preflight
+```
+
+This verifies release metadata, runs tests, builds and checks the generated documentation, builds `pkg/kward-VERSION.gem`, rejects development-only packaged files, and prints the final gem contents.
+
+Individual checks remain available:
 
 ```bash
-gem push kward-VERSION.gem
+bundle exec rake test
+bundle exec rake docs:check
+bundle exec rake release:verify
+bundle exec rake build
 ```
 
-RubyGems MFA is required for publishing. Prefer RubyGems trusted publishing for automated releases if CI publishing is added later, so long-lived API keys do not need to be stored in CI secrets.
+Use `bundle exec rake docs:serve` to preview documentation locally.
 
 ## If you need to yank a release
 
-If a published gem has a serious problem, you can yank it within 24 hours of pushing:
+If a published gem has a serious problem, yank it within 24 hours of pushing:
 
 ```bash
 gem yank kward --version VERSION
 ```
 
-Yanking removes the gem from the default install index but does not delete the version entirely. After yanking, fix the issue, bump the version, and release again.
+Yanking removes the gem from the default install index but does not delete the version. Fix the issue, choose a new version, and run the normal release command again. Never move or reuse a published version tag.

data/doc/security.md

@@ -58,7 +58,7 @@ 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.
+- 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

@@ -18,11 +18,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. Shell output 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 `!`:
 

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/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/rendering.rb

@@ -12,7 +12,12 @@ module Kward
 
       def redraw_interactive_prompt
         tab = active_tab if respond_to?(:active_tab, true)
-        if tab && (tab.running? || tab.shell)
+        clear_active_tab_transient_shell_output if tab && respond_to?(:clear_active_tab_transient_shell_output, true)
+        if tab&.shell
+          render_tab(tab, restore_composer: false)
+          return
+        end
+        if tab&.running?
           @prompt.redraw if @prompt.respond_to?(:redraw)
           return
         end
@@ -25,6 +30,7 @@ module Kward
 
         restore_prompt_transcript do
           tab ? render_transcript_messages(tab.driver.messages) : render_conversation_transcript(conversation)
+          render_tab_transient_shell_entries(tab) if tab && respond_to?(:render_tab_transient_shell_entries, true)
         end
       end
 
@@ -283,8 +289,14 @@ module Kward
       # Writes the pasted images output for the terminal CLI flow.
       def print_pasted_images(input, image_parts: nil)
         parts = image_parts || Kward::ImageAttachments.image_parts_from_text(input)
+        protocol = @prompt.inline_image_protocol if @prompt.respond_to?(:inline_image_protocol)
         parts.each do |part|
-          sequence = Kward::ImageAttachments.terminal_image_sequence(part)
+          next if @prompt.respond_to?(:inline_image_protocol) && protocol.nil?
+
+          part = Kward::ImageAttachments.terminal_image_part(part, protocol) if protocol
+          next if protocol && part.nil?
+
+          sequence = Kward::ImageAttachments.terminal_image_sequence(part, protocol: protocol)
           next unless sequence
 
           if @prompt.respond_to?(:say_visual)