kward 0.78.0 → 0.80.0

data/lib/kward/cli/slash_commands.rb

@@ -15,6 +15,9 @@ module Kward
         when "stats"
           run_busy_local_command_and_requeue { print_stats(argument) }
           [true, nil]
+        when "sandbox"
+          run_busy_local_command_and_requeue { handle_sandbox_command(argument, interactive_workspace_root(agent)) }
+          [true, nil]
         when "memory"
           activity = memory_summarize_command?(argument) ? "summarizing" : "loading"
           run_busy_local_command_and_requeue(activity: activity) { handle_memory_command(argument, agent) }
@@ -23,7 +26,11 @@ module Kward
           run_busy_local_command_and_requeue { handle_hooks_command(argument) }
           [true, nil]
         when "skill"
-          run_busy_local_command_and_requeue { activate_skill_command(argument, agent) }
+          if argument.to_s.strip == "capture"
+            capture_skill_from_session(session_store)
+          else
+            run_busy_local_command_and_requeue { activate_skill_command(argument, agent) }
+          end
           [true, nil]
         when "redraw"
           run_busy_local_command_and_requeue { @prompt.redraw if @prompt.respond_to?(:redraw) }
@@ -114,6 +121,48 @@ module Kward
         PromptCommands.parse(command) || [nil, ""]
       end
 
+      def handle_sandbox_command(argument, workspace_root)
+        action, value = argument.to_s.strip.split(/\s+/, 2)
+        case action
+        when nil, "", "status"
+          print_sandbox_status(workspace_root)
+        when *Sandbox::Policy::MODES
+          ConfigFiles.update_nested_config("sandbox", { "mode" => action })
+          runtime_output("Command sandbox mode set to #{action}. New sessions and tabs use the updated policy.")
+        when "network"
+          network = value.to_s
+          unless Sandbox::Policy::NETWORK_MODES.include?(network)
+            runtime_output("Usage: /sandbox network allow|deny")
+            return
+          end
+
+          ConfigFiles.update_nested_config("sandbox", { "network" => network })
+          runtime_output("Command sandbox child network set to #{network}. New sessions and tabs use the updated policy.")
+        else
+          runtime_output("Usage: /sandbox [status|off|read_only|workspace_write|network allow|network deny]")
+        end
+      rescue ArgumentError => error
+        runtime_output("Sandbox configuration error: #{error.message}")
+      end
+
+      def print_sandbox_status(workspace_root)
+        config = ConfigFiles.read_config
+        policy = ConfigFiles.sandbox_policy(workspace_root, config)
+        runner = Sandbox::RunnerFactory.build(policy)
+        capabilities = runner.capabilities
+        lines = [
+          "Command sandbox",
+          "Mode: #{policy.mode}",
+          "Child network: #{policy.network}",
+          "Backend: #{capabilities.backend}",
+          "Filesystem enforcement: #{capabilities.filesystem_enforced? ? "active" : "inactive"}",
+          "Child-network enforcement: #{capabilities.child_network_enforced? ? "active" : "inactive"}",
+          "Scope: model-requested run_shell_command workers only"
+        ]
+        lines << "Reason: #{capabilities.reason}" unless capabilities.reason.to_s.empty?
+        runtime_output(lines.join("\n"))
+      end
+
       def open_or_resume_session(session_store, argument)
         unless session_store
           say_sessions_unavailable
@@ -144,6 +193,65 @@ module Kward
         end
       end
 
+      def capture_skill_from_session(session_store)
+        unless session_store
+          say_sessions_unavailable
+          return
+        end
+        unless @prompt.respond_to?(:review_document)
+          runtime_output("Skill capture is available only in the interactive terminal prompt.")
+          return
+        end
+
+        source_path = select_skill_capture_session(session_store)
+        return unless source_path
+
+        capture = Skills::Capture.new(session_store: session_store, client: @client)
+        draft = run_busy_local_command_and_requeue(activity: "capturing skill") { capture.generate(source_path) }
+        review_captured_skill(capture, draft)
+      rescue Skills::Capture::Error => error
+        runtime_output("Skill capture failed: #{error.message}")
+      end
+
+      def select_skill_capture_session(session_store)
+        sessions = session_store.capture_candidates
+        if sessions.empty?
+          runtime_output("No saved sessions found.")
+          return nil
+        end
+
+        labels = session_picker_labels(sessions)
+        if @prompt.respond_to?(:select)
+          choice = @prompt.select("Capture session>", labels, title: "Capture skill from session")
+          return sessions[labels.index(choice)]&.path
+        end
+
+        runtime_output((["Saved sessions:"] + labels.each_with_index.map { |label, index| "#{index + 1}. #{label}" }).join("\n"))
+        answer = @prompt.ask("Session number or path>").to_s.strip
+        answer.match?(/\A\d+\z/) ? sessions[answer.to_i - 1]&.path : answer
+      end
+
+      def review_captured_skill(capture, draft)
+        overwrite = false
+        saved = nil
+        @prompt.review_document(title: "Review captured skill", content: draft.content) do |content|
+          begin
+            saved = capture.save(content, overwrite: overwrite)
+            nil
+          rescue Skills::Capture::ConflictError
+            if overwrite
+              "Could not overwrite the existing skill. Review the name and try again."
+            else
+              overwrite = true
+              "A personal skill with this name exists. Press Ctrl+S again to overwrite it."
+            end
+          rescue Skills::Capture::Error => error
+            error.message
+          end
+        end
+        runtime_output("Saved personal skill: #{capture.skill_path(saved.name)}") if saved
+      end
+
       def activate_skill_command(name, agent)
         skill_name = name.to_s.strip
         if skill_name.empty?

data/lib/kward/cli/tabs.rb

@@ -8,6 +8,12 @@ module Kward
   class CLI
     # TUI session tab coordination and asynchronous turn execution.
     module Tabs
+      WORKTREE_AGENT_CONTEXT = <<~PROMPT.strip.freeze
+        This is an active Git worktree tab. The workspace is sandboxed separately from the host repository metadata.
+        When the user explicitly asks you to commit, use the advertised `git_commit` tool. Do not use `run_shell_command` for `git add` or `git commit`, because shared Git metadata is intentionally protected there.
+        `git_commit` requires a commit message and accepts optional workspace-relative paths; omit paths to include all current changes in this worktree. Do not create a commit unless the user requested one.
+      PROMPT
+
       TabRuntime = Struct.new(
         :session,
         :agent,
@@ -91,6 +97,7 @@ module Kward
         @active_tab_index = 0
         @tab_store = session_store ? TabStore.new(config_dir: session_store.config_dir, cwd: session_store.cwd) : nil
         @tab_live_view = nil
+        @tab_live_view_token = nil
         @restored_tabs = false
         restored = restore_tabs(session_store) if session_store && agent.nil?
         return restored if restored
@@ -120,11 +127,14 @@ module Kward
         descriptors = Array(data["tabs"])
         return nil if descriptors.empty?
 
-        descriptors.each_with_index do |_descriptor, index|
-          tab = build_tab_from_descriptor(data.fetch("tabs")[index], session_store, label: restored_tab_label(data, index))
+        descriptors.each_with_index do |descriptor, index|
+          tab = build_tab_from_descriptor(descriptor, session_store, label: restored_tab_label(data, index))
           @tabs << tab if tab
-        rescue StandardError
-          next
+        rescue StandardError => e
+          descriptor = descriptor.transform_keys(&:to_s) if descriptor.respond_to?(:transform_keys)
+          if descriptor.is_a?(Hash) && descriptor.key?("worktree")
+            @tabs << unavailable_worktree_tab(descriptor, e, label: restored_tab_label(data, index))
+          end
         end
         return nil if @tabs.empty?
 
@@ -136,13 +146,21 @@ module Kward
       def build_tab_from_descriptor(descriptor, session_store, label: nil)
         descriptor = descriptor.transform_keys(&:to_s)
         if descriptor["kind"] == "session"
-          session, conversation = restore_tab_session(session_store, descriptor.fetch("session_path"))
-          agent = build_tab_agent(conversation, session)
-          return build_tab(session, agent, driver: SessionTabDriver.new(session: session, agent: agent), label: label)
+          worktree = if descriptor.key?("worktree")
+            binding = GitWorktreeBinding.from_descriptor(descriptor["worktree"])
+            raise GitWorktreeManager::Error, "Invalid worktree binding." unless binding
+
+            binding
+          end
+          validate_worktree_binding!(worktree)
+          root = worktree_root_for(worktree, fallback: session_store.cwd)
+          session, conversation = restore_tab_session(session_store, descriptor.fetch("session_path"), workspace_root: root, strict: worktree&.active? == true)
+          agent = build_tab_agent(conversation, session, worktree: worktree)
+          return build_tab(session, agent, driver: SessionTabDriver.new(session: session, agent: agent, worktree: worktree), label: label)
         end
 
         tab_type = plugin_registry.tab_type_for_id(descriptor["plugin_tab_type"])
-        driver = if tab_type
+        driver = if tab_type&.local
           host = PluginTabHost.new(client: @client, workspace_root: session_store.cwd)
           tab_type.handler.call(host, descriptor)
         else
@@ -154,7 +172,7 @@ module Kward
 
       def open_plugin_tab(name, session_store)
         tab_type = plugin_registry.tab_type_for(name)
-        return runtime_output("Plugin tab #{name.inspect} is not available.") unless tab_type
+        return runtime_output("Plugin tab #{name.inspect} is not available.") unless tab_type&.local
 
         if tab_type.singleton == :global && (existing = @tabs.find { |tab| tab.driver.descriptor["plugin_tab_type"] == tab_type.id })
           return switch_tab(@tabs.index(existing))
@@ -174,30 +192,37 @@ module Kward
         runtime_output("Could not open plugin tab #{name.inspect}: #{e.message}")
       end
 
-      def restore_tab_session(session_store, path)
+      def restore_tab_session(session_store, path, workspace_root: session_store.cwd, strict: false)
         if File.file?(path)
-          session, conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
+          session, conversation = session_store.load(path, workspace: configured_workspace(root: workspace_root, strict: strict), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
           return [track_session(session), conversation]
         end
 
         session = track_session(session_store.create(provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort))
-        conversation = new_conversation(workspace_root: session_store.cwd)
+        conversation = new_conversation(workspace_root: workspace_root)
         session.attach(conversation)
         [session, conversation]
       end
 
-      def build_tab_agent(conversation, _session)
+      def build_tab_agent(conversation, _session, worktree: nil)
         conversation.plugin_registry ||= plugin_registry if conversation.respond_to?(:plugin_registry)
-        workspace = configured_workspace(root: conversation.workspace_root)
+        strict = worktree&.active? == true
+        update_worktree_agent_context(conversation, strict)
+        workspace = configured_workspace(root: conversation.workspace_root, strict: strict)
         prompt = TabQuestionPrompt.new(self)
-        hook_manager = lifecycle_hook_manager(conversation)
-        hook_context = lifecycle_hook_context(conversation)
+        hook_manager = strict ? nil : lifecycle_hook_manager(conversation)
+        hook_context = strict ? nil : lifecycle_hook_context(conversation)
+        git_committer = if strict
+                          ->(message:, paths:) { git_commit_for_agent(workspace.root.to_s, message: message, paths: paths) }
+                        end
         tool_registry = ToolRegistry.new(
           workspace: workspace,
           prompt: prompt,
           tool_approval: tab_tool_approval_callback(prompt),
           hook_manager: hook_manager,
-          hook_context: hook_context
+          hook_context: hook_context,
+          mcp_clients: strict ? [] : nil,
+          git_committer: git_committer
         )
         @footer_conversation = conversation
         @footer_tool_registry = tool_registry
@@ -212,6 +237,14 @@ module Kward
         agent
       end
 
+      def update_worktree_agent_context(conversation, strict)
+        desired = strict ? WORKTREE_AGENT_CONTEXT : nil
+        return if conversation.execution_profile_context == desired
+        return unless strict || conversation.execution_profile_context == WORKTREE_AGENT_CONTEXT
+
+        conversation.update_execution_profile_context!(desired)
+      end
+
       def tab_tool_approval_callback(prompt)
         return nil unless ConfigFiles.permission_policy(safely_read_config.to_h).enabled?
 
@@ -372,8 +405,9 @@ module Kward
         return agent unless tab
 
         tab.session = @active_session
-        tab.agent = build_tab_agent(agent.conversation, tab.session)
-        tab.driver = SessionTabDriver.new(session: tab.session, agent: tab.agent)
+        worktree = reconcile_worktree_binding(tab, agent.conversation)
+        tab.agent = build_tab_agent(agent.conversation, tab.session, worktree: worktree)
+        tab.driver = SessionTabDriver.new(session: tab.session, agent: tab.agent, worktree: worktree)
         assign_tab_question_prompt(tab.agent, tab)
         tab.diff = @session_diff || (tab.session&.path ? SessionDiff.from_session_file(tab.session.path) : SessionDiff.new)
         tab.snapshot = nil
@@ -389,6 +423,7 @@ module Kward
         tab.shell = nil
         tab.stream_state = new_tab_stream_state(tab.driver)
         tab.markdown_chunks.clear
+        update_prompt_workspace_root(current_workspace_root)
         update_prompt_tabs
         persist_tabs
         tab.agent
@@ -399,13 +434,23 @@ module Kward
         return unless tab
 
         if @prompt.respond_to?(:tab_view_snapshot)
-          tab.snapshot = @prompt.tab_view_snapshot
+          tab.snapshot = tab_view_snapshot_for(tab)
         elsif @prompt.respond_to?(:composer_snapshot)
           tab.snapshot = @prompt.composer_snapshot
         end
         tab.diff = @session_diff
       end
 
+      def tab_view_snapshot_for(tab)
+        snapshot_method = @prompt.method(:tab_view_snapshot)
+        supports_transcript_option = snapshot_method.parameters.any? do |type, name|
+          type == :keyrest || ([:key, :keyreq].include?(type) && name == :include_transcript)
+        end
+        return snapshot_method.call unless supports_transcript_option
+
+        snapshot_method.call(include_transcript: tab.running? || !tab.shell.nil?)
+      end
+
       def activate_tab(index, render: true)
         tab = @tabs[index]
         return nil unless tab
@@ -424,6 +469,8 @@ module Kward
         end
         tab.unread = false
         restore_tab_composer_snapshot(tab.snapshot)
+        update_prompt_workspace_root(current_workspace_root)
+        @prompt.refresh_composer_status if @prompt.respond_to?(:refresh_composer_status)
         update_plugin_tab_slash_commands(tab)
         update_prompt_tabs
         render_tab(tab) if render
@@ -640,12 +687,12 @@ module Kward
 
       def refresh_active_tab
         tab = active_tab
-        return unless tab
+        return unless tab&.thread && !tab.thread.alive? && tab.running?
 
-        if tab.thread && !tab.thread.alive? && tab.running?
-          tab.thread.join
-          tab.status = "ready" if tab.status == "running"
-        end
+        tab.thread.join
+        return unless tab.status == "running"
+
+        tab.status = "ready"
         update_prompt_tabs
       end
 
@@ -653,23 +700,31 @@ module Kward
         return unless prompt_interface?
 
         stop_tab_live_view
-        @tab_live_view_stop = false
-        @tab_live_view = Thread.new { run_tab_live_view(tab) }
+        token = Object.new
+        @tab_live_view_token = token
+        @tab_live_view = Thread.new { run_tab_live_view(tab, token) }
         @tab_live_view.report_on_exception = false
       end
 
       def stop_tab_live_view
-        @tab_live_view_stop = true
-        @tab_live_view&.join(0.2)
-        @tab_live_view = nil
+        thread = @tab_live_view
+        @tab_live_view_token = nil
+        thread&.join(0.2)
+        @tab_live_view = nil if @tab_live_view.equal?(thread)
       end
 
-      def run_tab_live_view(tab)
+      def run_tab_live_view(tab, token)
         renderer = tab_live_renderer(tab)
-        until @tab_live_view_stop
+        while @tab_live_view_token.equal?(token)
           events = tab.event_history[tab.seen_events..] || []
-          events.each { |event| renderer.call(event, tab.driver) }
-          tab.seen_events += events.length
+          events.each do |event|
+            break unless @tab_live_view_token.equal?(token)
+
+            renderer.call(event, tab.driver)
+            tab.seen_events += 1
+          end
+          break unless @tab_live_view_token.equal?(token)
+
           if tab.idle?
             renderer.call(:flush, tab.driver)
             break
@@ -677,7 +732,8 @@ module Kward
           sleep 0.05
         end
       ensure
-        @tab_live_view_stop = false if @tab_live_view == Thread.current
+        @tab_live_view_token = nil if @tab_live_view_token.equal?(token)
+        @tab_live_view = nil if @tab_live_view == Thread.current
       end
 
       def tab_live_renderer(tab)
@@ -726,6 +782,8 @@ module Kward
       def tab_labels
         @tabs.each_with_index.map do |tab, index|
           label = tab.label.to_s.empty? ? default_tab_label(index) : tab.label.to_s
+          binding = worktree_binding_for(tab)
+          label = "#{label} · #{binding.branch}" if binding&.active?
           { name: label, color: tab_label_color(tab) }
         end
       end
@@ -752,7 +810,7 @@ module Kward
         action, value = argument.to_s.strip.split(/\s+/, 2)
         case action
         when nil, ""
-          runtime_output("Usage: /tab 1-n | /tab move 1-n|left|right | /tab close | /tab new | /tab open <plugin-tab> | /tab name <label>")
+          runtime_output(tab_usage)
           nil
         when /^\d+$/
           switch_tab_number(action)
@@ -774,12 +832,19 @@ module Kward
         when "name", "rename"
           rename_active_tab(value)
           active_tab&.agent
+        when "worktree"
+          handle_worktree_command(value)
+          active_tab&.agent
         else
-          runtime_output("Usage: /tab 1-n | /tab move 1-n|left|right | /tab close | /tab new | /tab open <plugin-tab> | /tab name <label>")
+          runtime_output(tab_usage)
           nil
         end
       end
 
+      def tab_usage
+        "/tab 1-n | /tab move 1-n|left|right | /tab close | /tab new | /tab open <plugin-tab> | /tab name <label> | /tab worktree [activate|detach|status|merge|merge abort|remove]"
+      end
+
       def switch_tab_number(number)
         index = number.to_i - 1
         return switch_tab(index) if @tabs && index.between?(0, @tabs.length - 1)

data/lib/kward/cli/transports.rb

@@ -0,0 +1,67 @@
+require_relative "../transport/runtime"
+
+module Kward
+  class CLI
+    # Foreground transport lifecycle commands.
+    module Transports
+      private
+
+      def handle_transport_command(arguments)
+        command = arguments.first.to_s
+        case command
+        when "list"
+          raise ArgumentError, command_usage("transport") unless arguments.length == 1
+
+          with_transport_runtime { |runtime| print_transport_entries(runtime.manager.list) }
+        when "status"
+          raise ArgumentError, command_usage("transport") unless arguments.length <= 2
+
+          with_transport_runtime do |runtime|
+            entries = arguments.length == 2 ? [runtime.manager.status(arguments[1])] : runtime.manager.status
+            print_transport_entries(entries)
+          end
+        when "run"
+          raise ArgumentError, command_usage("transport") unless (2..3).cover?(arguments.length)
+
+          workspace_root = arguments[2] ? expanded_working_directory(arguments[2]) : @working_directory
+          run_transport(arguments[1], workspace_root: workspace_root)
+        else
+          raise ArgumentError, command_usage("transport")
+        end
+      end
+
+      def print_transport_entries(entries)
+        entries.each do |entry|
+          @prompt.say("#{entry[:id]}\t#{entry[:state] || "stopped"}")
+        end
+      end
+
+      def run_transport(name, workspace_root: nil)
+        runtime = Transport::Runtime.new(client: ensure_client!)
+        runtime.manager.start(name, workspace_root: workspace_root)
+        @prompt.say("Transport #{name} is running. Press Ctrl-C to stop.")
+        wait_for_transport_shutdown
+      ensure
+        runtime&.shutdown
+      end
+
+      def with_transport_runtime
+        runtime = Transport::Runtime.new(client: ensure_client!)
+        yield runtime
+      ensure
+        runtime&.shutdown
+      end
+
+      def wait_for_transport_shutdown
+        stopped = false
+        previous_handlers = {}
+        %w[INT TERM].each do |signal|
+          previous_handlers[signal] = Signal.trap(signal) { stopped = true }
+        end
+        sleep 0.1 until stopped
+      ensure
+        previous_handlers&.each { |signal, handler| Signal.trap(signal, handler) }
+      end
+    end
+  end
+end