kward 0.80.1 → 0.82.0

data/lib/kward/cli/runtime_helpers.rb

@@ -4,10 +4,20 @@ module Kward
   class CLI
     # Shared runtime construction helpers for CLI conversations, workspaces, plugins, and sessions.
     module RuntimeHelpers
+      MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES = 1_048_576
+      UNSAFE_TRANSCRIPT_CONTROL_PATTERN = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/.freeze
+
       private
 
       def new_conversation(workspace_root: current_workspace_root)
-        Conversation.new(workspace_root: workspace_root, provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort, plugin_registry: plugin_registry)
+        Conversation.new(
+          workspace_root: workspace_root,
+          provider: current_model_provider,
+          model: current_model_id,
+          reasoning_effort: current_reasoning_effort,
+          plugin_registry: plugin_registry,
+          project_skill_paths: project_skill_paths_for(workspace_root)
+        )
       end
 
       def update_assistant_prompt(conversation)
@@ -50,6 +60,7 @@ module Kward
         tool_registry = ToolRegistry.new(
           workspace: workspace,
           prompt: @prompt,
+          skills: ConfigFiles.skills(workspace_root: conversation.workspace_root, project_skill_paths: project_skill_paths_for(conversation.workspace_root)),
           tool_approval: interactive_tool_approval_callback,
           hook_manager: hook_manager,
           hook_context: hook_context
@@ -86,17 +97,91 @@ module Kward
           return true
         end
 
+        shell = bang_shell(agent)
+        editor_result = shell.editor_command_result(command)
+        if editor_result
+          record_tab_transient_shell_output(editor_result.output, render: false)
+          @prompt.say(editor_result.output) unless editor_result.output.to_s.empty?
+          open_ekwsh_editor(editor_result.open_editor_path, shell) if editor_result.open_editor_path
+          return true
+        end
+
+        expanded_command = shell.expand_alias(command, interactive: true)
+        run_user_interactive_pty_command(
+          expanded_command,
+          shell: Ekwsh::DEFAULT_SHELL,
+          env: interactive_pty_environment({}, preserve_git_pager: true),
+          cwd: interactive_workspace_root(agent),
+          intro: "$ #{command}\n"
+        )
+        true
+      end
+
+      def run_captured_shell_command(command, agent)
+        command = command.to_s.strip
+        if command.empty?
+          runtime_output("Usage: /capture <command>")
+          return
+        end
+
         run_busy_local_command_and_requeue(activity: "running") do
-          result = configured_workspace(root: interactive_workspace_root(agent)).run_shell_command(command)
+          result = Workspace.new(root: interactive_workspace_root(agent)).run_shell_command(command)
           @prompt.say("\n#{colored("Shell>", :cyan, :bold)} #{command}\n#{result}\n")
         end
-        true
       end
 
       def shell_command_input?(input)
         input.to_s.start_with?("!")
       end
 
+      def complete_bang_command(input, cursor, agent)
+        value = input.to_s
+        return false unless value.start_with?("!")
+        return nil if cursor.to_i <= 1
+
+        completion = bang_shell(agent).complete(value[1..], cursor.to_i - 1)
+        return nil unless completion
+
+        Ekwsh::Completion.new(
+          range: (completion.range.begin + 1)...(completion.range.end + 1),
+          replacement: completion.replacement,
+          candidates: completion.candidates
+        )
+      end
+
+      def bang_shell(agent)
+        root = File.expand_path(interactive_workspace_root(agent).to_s)
+        aliases = ConfigFiles.read_ekwsh_config[:aliases]
+        cache_key = [root, ENV.fetch("PATH", ""), aliases.sort]
+        return @bang_shell if @bang_shell_key == cache_key
+
+        @bang_shell_key = cache_key
+        @bang_shell = Ekwsh.new(cwd: root, env: ENV.to_h, aliases: aliases)
+      end
+
+      def install_bang_completion_provider(agent)
+        return unless @prompt.respond_to?(:update_completion_provider)
+
+        @bang_completion_provider_installed = true
+        provider = lambda do |input, cursor|
+          current_agent = if respond_to?(:active_tab, true) && active_tab&.agent
+            active_tab.agent
+          else
+            agent
+          end
+          complete_bang_command(input, cursor, current_agent)
+        end
+        @prompt.update_completion_provider(provider)
+      end
+
+      def clear_bang_completion_provider
+        return unless @bang_completion_provider_installed
+        return unless @prompt.respond_to?(:update_completion_provider)
+
+        @prompt.update_completion_provider(nil)
+        @bang_completion_provider_installed = false
+      end
+
       def run_ekwsh(agent)
         unless @prompt.respond_to?(:ask)
           runtime_output("The embedded shell is only available in interactive mode.")
@@ -140,29 +225,118 @@ module Kward
         end
 
         config = ConfigFiles.read_ekwsh_config
-        env = interactive_pty_environment(config[:env])
-        cwd = interactive_workspace_root(agent)
-        @prompt.say("$ #{command}\n[interactive PTY session started]\n") if @prompt.respond_to?(:say)
-        result = run_interactive_pty_with_terminal_handoff(config[:shell], command, env: env, cwd: cwd)
-        @prompt.say("[interactive PTY session exited with status #{result.exit_status}]\n") if @prompt.respond_to?(:say)
+        run_user_interactive_pty_command(
+          command,
+          shell: config[:shell],
+          env: interactive_pty_environment(config[:env]),
+          cwd: interactive_workspace_root(agent)
+        )
+      end
+
+      def run_user_interactive_pty_command(command, shell:, env:, cwd:, intro: nil)
+        intro_message = intro || "$ #{command}\n"
+        record_tab_transient_shell_output(intro_message, render: false)
+        if @prompt.respond_to?(:write_transcript)
+          @prompt.write_transcript(intro_message)
+        elsif @prompt.respond_to?(:say)
+          @prompt.say(intro_message)
+        end
+        result = run_interactive_pty_with_terminal_handoff(shell, command, env: env, cwd: cwd) do |sink, completed_result|
+          record_completed_pty_output(sink, completed_result)
+        end
+        refresh_composer_status
+        result
       rescue Errno::ENOENT => e
         runtime_output("Error: #{e.message}")
+        nil
       end
 
-      def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:)
+      def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:, &on_complete)
         runner = InteractivePtyRunner.new
-        if @prompt.respond_to?(:with_terminal_handoff)
+        run_with_sink = lambda do |input, sink|
+          result = runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, sink: sink)
+          on_complete.call(sink, result) if on_complete
+          result
+        end
+
+        if @prompt.respond_to?(:with_inline_terminal_handoff)
+          @prompt.with_inline_terminal_handoff do |input, output, transition|
+            sink = AdaptivePtyOutputSink.new(
+              output: output,
+              on_exclusive: transition,
+              max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
+            )
+            run_with_sink.call(input, sink)
+          end
+        elsif @prompt.respond_to?(:with_terminal_handoff)
           @prompt.with_terminal_handoff do |input, output|
-            runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, output: output)
+            sink = PassthroughPtyOutputSink.new(
+              output: output,
+              max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
+            )
+            run_with_sink.call(input, sink)
           end
         else
-          runner.run(shell, "-c", command, env: env, cwd: cwd)
+          sink = PassthroughPtyOutputSink.new(
+            output: $stdout,
+            max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
+          )
+          run_with_sink.call($stdin, sink)
         end
       end
 
-      def interactive_pty_environment(configured_env)
+      def record_completed_pty_output(sink, result)
+        classified_output = sink.respond_to?(:transcript_safe?)
+        return if classified_output && !sink.transcript_safe?
+
+        output = sink&.captured_output || +"".b
+        allow_input = classified_output &&
+          sink.respond_to?(:pre_input_capture_only?) &&
+          sink.pre_input_capture_only?
+        transcript_output = terminal_transcript_output(
+          output,
+          result,
+          truncated: sink&.truncated? || false,
+          allow_input: allow_input,
+          normalize_line_controls: classified_output
+        )
+        return unless transcript_output
+
+        record_tab_transient_shell_output(transcript_output, render: false)
+        if @prompt.respond_to?(:record_transient_terminal_output)
+          @prompt.record_transient_terminal_output(transcript_output, render: false)
+        end
+      end
+
+      def terminal_transcript_output(
+        output,
+        result,
+        truncated:,
+        allow_input: false,
+        normalize_line_controls: false
+      )
+        return if truncated || (result.input_forwarded && !allow_input)
+
+        text = ANSI.normalize_transcript_encoding(output).gsub("\r\n", "\n")
+        return if text.empty?
+
+        if normalize_line_controls
+          sanitized = PtyTranscriptNormalizer.normalize(text)
+        else
+          return if text.include?("\r")
+
+          sanitized = ANSI.sanitize_transcript(text)
+          return unless sanitized == text
+        end
+        return if sanitized.empty?
+        return if ANSI.strip_control_sequences(sanitized).match?(UNSAFE_TRANSCRIPT_CONTROL_PATTERN)
+
+        sanitized
+      end
+
+      def interactive_pty_environment(configured_env, preserve_git_pager: false)
         ENV.to_h.merge(configured_env.to_h.transform_keys(&:to_s).transform_values(&:to_s)).tap do |env|
-          env.delete("GIT_PAGER") if env["GIT_PAGER"] == "cat"
+          env.delete("GIT_PAGER") if !preserve_git_pager && env["GIT_PAGER"] == "cat"
           env["TERM"] = "xterm-256color" if env["TERM"].to_s.empty? || env["TERM"] == "dumb"
         end
       end
@@ -191,8 +365,13 @@ module Kward
           break if input.nil?
 
           result = run_ekwsh_command(shell, input)
-          @prompt.clear_transcript if result.clear && @prompt.respond_to?(:clear_transcript)
-          @prompt.say(result.output) unless result.streamed || result.interactive_command || result.output.to_s.empty?
+          if result.clear
+            clear_active_tab_transient_shell_output
+            @prompt.clear_transcript if @prompt.respond_to?(:clear_transcript)
+          else
+            record_tab_transient_shell_output(result.output, render: false) unless result.interactive_command
+            @prompt.say(result.output) unless result.streamed || result.interactive_command || result.output.to_s.empty?
+          end
           return :tab_action if pending_tab_action?
 
           if result.open_editor_path
@@ -249,14 +428,13 @@ module Kward
       end
 
       def run_ekwsh_interactive_pty_command(shell, result)
-        @prompt.say(result.output) unless result.output.to_s.empty?
-        pty_result = run_interactive_pty_with_terminal_handoff(
-          shell.command_shell,
+        run_user_interactive_pty_command(
           result.interactive_command,
+          shell: shell.command_shell,
           env: shell.child_env(interactive: true),
-          cwd: shell.cwd
+          cwd: shell.cwd,
+          intro: result.output
         )
-        @prompt.say("[interactive PTY session exited with status #{pty_result.exit_status}]\n") if @prompt.respond_to?(:say)
       end
 
       def run_ekwsh_command(shell, input)
@@ -306,6 +484,21 @@ module Kward
         result
       end
 
+      def record_tab_transient_shell_output(text, render: true)
+        value = text.to_s
+        return if value.empty?
+
+        tab = active_tab if respond_to?(:active_tab, true)
+        tab&.append_transient_shell_entry(value)
+        if render && @prompt.respond_to?(:record_transient_terminal_output)
+          @prompt.record_transient_terminal_output(value)
+        end
+      end
+
+      def clear_active_tab_transient_shell_output
+        clear_active_tab_transient_shell_entries if respond_to?(:clear_active_tab_transient_shell_entries, true)
+      end
+
       def drain_ekwsh_chunks(chunks)
         loop do
           @prompt.write_transcript_delta(chunks.pop(true))
@@ -422,6 +615,14 @@ module Kward
         @client.respond_to?(:current_reasoning_effort) ? @client.current_reasoning_effort : ModelInfo::DEFAULT_REASONING_EFFORT
       end
 
+      def refresh_composer_status
+        if @prompt.respond_to?(:refresh_composer_status)
+          @prompt.refresh_composer_status
+        elsif @prompt.respond_to?(:redraw)
+          @prompt.redraw
+        end
+      end
+
       def reload_client_config
         @client.reload_config if @client.respond_to?(:reload_config)
       end

data/lib/kward/cli/sessions.rb

@@ -21,7 +21,7 @@ module Kward
         path = session_store.remembered_last_session_path if session_store.respond_to?(:remembered_last_session_path)
         return nil if path.to_s.empty?
 
-        @active_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)
+        @active_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, project_skill_paths: project_skill_paths_for(session_store.cwd) || [])
         reset_session_diff(@active_session.path)
         track_session(@active_session)
         @resumed_last_session = true
@@ -99,6 +99,7 @@ module Kward
       def start_new_session(session_store)
         return say_sessions_unavailable unless session_store
 
+        prepare_interactive_project_skills if respond_to?(:prepare_interactive_project_skills, true)
         previous_session = @active_session
         @active_session = track_session(session_store.create)
         reset_session_diff
@@ -127,7 +128,7 @@ module Kward
 
       def load_session(session_store, path, message: nil)
         previous_session = @active_session
-        @active_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)
+        @active_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, project_skill_paths: project_skill_paths_for(session_store.cwd) || [])
         reset_session_diff(@active_session.path)
         track_session(@active_session)
         cleanup_replaced_session(previous_session)
@@ -396,7 +397,8 @@ module Kward
           workspace: configured_workspace(root: session_store.cwd),
           provider: current_model_provider,
           model: current_model_id,
-          reasoning_effort: current_reasoning_effort
+          reasoning_effort: current_reasoning_effort,
+          project_skill_paths: project_skill_paths_for(session_store.cwd) || []
         )
         reset_session_diff(@active_session.path)
         track_session(@active_session)
@@ -579,7 +581,7 @@ module Kward
       end
 
       def clone_session_file_from_path(session_store, path)
-        source_session, source_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)
+        source_session, source_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, project_skill_paths: project_skill_paths_for(session_store.cwd) || [])
         clone, = session_store.create_independent_from_conversation(source_conversation, parent_session: source_session)
         clone.path
       end

data/lib/kward/cli/settings.rb

@@ -115,7 +115,7 @@ module Kward
         ConfigFiles.update_config("provider" => ModelInfo.config_provider_for_provider(provider))
         reload_client_config
         refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        refresh_composer_status
       end
 
       def provider_choices
@@ -166,7 +166,7 @@ module Kward
         ConfigFiles.update_config("local_backend" => backend, "local_base_url" => url)
         reload_client_config
         refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        refresh_composer_status
       end
 
       def configure_account_settings
@@ -920,7 +920,7 @@ module Kward
         ConfigFiles.update_config(ModelInfo.config_values_for_selection(provider, model))
         reload_client_config
         refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        refresh_composer_status
       end
 
       REASONING_CONFIG_DEBOUNCE_SECONDS = 0.5
@@ -953,18 +953,10 @@ module Kward
         queue_reasoning_config(effort, provider: provider, conversation: conversation) if queue_config
         if queue_config
           update_conversation_reasoning_effort(conversation, effort)
-          refresh_reasoning_status
+          refresh_composer_status
         else
           refresh_conversation_runtime(conversation, reasoning_effort: effort)
-          @prompt.redraw if @prompt.respond_to?(:redraw)
-        end
-      end
-
-      def refresh_reasoning_status
-        if @prompt.respond_to?(:refresh_composer_status)
-          @prompt.refresh_composer_status
-        else
-          @prompt.redraw if @prompt.respond_to?(:redraw)
+          refresh_composer_status
         end
       end
 

data/lib/kward/cli/slash_commands.rb

@@ -32,6 +32,9 @@ module Kward
             run_busy_local_command_and_requeue { activate_skill_command(argument, agent) }
           end
           [true, nil]
+        when "skills"
+          run_busy_local_command_and_requeue { handle_project_skills_command(argument) }
+          [true, nil]
         when "redraw"
           run_busy_local_command_and_requeue { @prompt.redraw if @prompt.respond_to?(:redraw) }
           [true, nil]
@@ -47,6 +50,9 @@ module Kward
         when "shell"
           run_ekwsh(agent)
           [true, nil]
+        when "capture"
+          run_captured_shell_command(argument, agent)
+          [true, nil]
         when "scratchpad"
           open_scratchpad_command(argument)
           [true, nil]

data/lib/kward/cli/tabs.rb

@@ -35,10 +35,13 @@ module Kward
         :unread,
         :pending_question,
         :shell,
+        :transient_shell_entries,
         :error_reported,
         :local_busy_activity,
         keyword_init: true
       ) do
+        TRANSIENT_SHELL_OUTPUT_LIMIT = 200_000
+
         def running?
           %w[queued running waiting_for_question].include?(status.to_s)
         end
@@ -54,6 +57,41 @@ module Kward
         def record_event(event)
           event_history << event
         end
+
+        def append_transient_shell_entry(text)
+          value = text.to_s
+          return if value.empty?
+
+          self.transient_shell_entries ||= []
+          transient_shell_entries << value
+          trim_transient_shell_entries
+        end
+
+        def clear_transient_shell_entries
+          self.transient_shell_entries = []
+        end
+
+        private
+
+        def trim_transient_shell_entries
+          combined = transient_shell_entries.join
+          return if combined.length <= TRANSIENT_SHELL_OUTPUT_LIMIT
+
+          target = (TRANSIENT_SHELL_OUTPUT_LIMIT * 0.9).floor
+          cutoff = combined.length - target
+          newline = combined.index("\n", cutoff)
+          cutoff = newline + 1 if newline
+          cutoff = transient_shell_escape_boundary(combined, cutoff)
+          self.transient_shell_entries = [combined[cutoff..].to_s]
+        end
+
+        def transient_shell_escape_boundary(text, cutoff)
+          escape_start = text.rindex("\e", cutoff)
+          return cutoff unless escape_start
+
+          escape = ANSI.escape_sequence_at(text, escape_start)
+          escape && escape_start + escape.length > cutoff ? escape_start + escape.length : cutoff
+        end
       end
 
       class TabQuestionPrompt
@@ -194,7 +232,7 @@ module Kward
 
       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: workspace_root, strict: strict), 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, project_skill_paths: project_skill_paths_for(workspace_root) || [])
           return [track_session(session), conversation]
         end
 
@@ -215,9 +253,11 @@ module Kward
         git_committer = if strict
                           ->(message:, paths:) { git_commit_for_agent(workspace.root.to_s, message: message, paths: paths) }
                         end
+        project_skill_paths = project_skill_paths_for(conversation.workspace_root) || []
         tool_registry = ToolRegistry.new(
           workspace: workspace,
           prompt: prompt,
+          skills: ConfigFiles.skills(workspace_root: conversation.workspace_root, project_skill_paths: project_skill_paths),
           tool_approval: tab_tool_approval_callback(prompt),
           hook_manager: hook_manager,
           hook_context: hook_context,
@@ -277,6 +317,7 @@ module Kward
           unread: false,
           pending_question: nil,
           shell: nil,
+          transient_shell_entries: [],
           error_reported: false,
           local_busy_activity: nil
         ).tap { |tab| assign_tab_question_prompt(agent, tab) }
@@ -422,6 +463,7 @@ module Kward
         tab.queued_inputs.clear
         tab.steering = nil
         tab.shell = nil
+        tab.clear_transient_shell_entries
         tab.stream_state = new_tab_stream_state(tab.driver)
         tab.markdown_chunks.clear
         update_prompt_workspace_root(current_workspace_root)
@@ -449,7 +491,7 @@ module Kward
         end
         return snapshot_method.call unless supports_transcript_option
 
-        snapshot_method.call(include_transcript: tab.running? || !tab.shell.nil?)
+        snapshot_method.call(include_transcript: tab.running?)
       end
 
       def activate_tab(index, render: true)
@@ -482,8 +524,8 @@ module Kward
         tab.agent
       end
 
-      def render_tab(tab)
-        if tab.snapshot && @prompt.respond_to?(:restore_tab_view_snapshot) && (tab.running? || tab.shell)
+      def render_tab(tab, restore_composer: true)
+        if restore_composer && tab.snapshot && @prompt.respond_to?(:restore_tab_view_snapshot) && tab.running?
           @prompt.restore_tab_view_snapshot(tab.snapshot)
           return
         end
@@ -495,8 +537,23 @@ module Kward
             render_transcript_messages(tab.driver.messages)
           end
           report_tab_runtime_error(tab) if %w[failed cancelled].include?(tab.status.to_s)
+          render_tab_transient_shell_entries(tab)
         end
-        restore_tab_composer_snapshot(tab.snapshot)
+        restore_tab_composer_snapshot(tab.snapshot) if restore_composer
+      end
+
+      def render_tab_transient_shell_entries(tab)
+        Array(tab.transient_shell_entries).each do |entry|
+          if @prompt.respond_to?(:say)
+            @prompt.say(entry)
+          elsif @prompt.respond_to?(:write_transcript)
+            @prompt.write_transcript(entry)
+          end
+        end
+      end
+
+      def clear_active_tab_transient_shell_entries
+        active_tab&.clear_transient_shell_entries
       end
 
       def restore_tab_composer_snapshot(snapshot)

data/lib/kward/cli.rb

@@ -16,6 +16,8 @@ require_relative "events"
 require_relative "export_path"
 require_relative "ekwsh"
 require_relative "interactive_pty_runner"
+require_relative "adaptive_pty_output_sink"
+require_relative "pty_transcript_normalizer"
 require_relative "auth/anthropic_oauth"
 require_relative "auth/api_key_store"
 require_relative "auth/github_oauth"
@@ -59,6 +61,8 @@ require_relative "cli/sysprompt"
 require_relative "cli/stats"
 require_relative "cli/openrouter_commands"
 require_relative "cli/runtime_helpers"
+require_relative "cli/project_skills"
+require_relative "cli/project_skills_commands"
 require_relative "cli/slash_commands"
 require_relative "cli/memory_commands"
 require_relative "cli/hook_commands"
@@ -94,6 +98,8 @@ module Kward
     include CLI::Stats
     include CLI::OpenRouterCommands
     include CLI::RuntimeHelpers
+    include CLI::ProjectSkills
+    include CLI::ProjectSkillsCommands
     include CLI::SlashCommands
     include CLI::MemoryCommands
     include CLI::HookCommands
@@ -232,6 +238,16 @@ module Kward
         return
       end
 
+      if @argv.first == "skills"
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("skills")
+          return
+        end
+
+        handle_project_skills_cli_command(@argv[1..] || [])
+        return
+      end
+
       if @argv.first == "edit"
         if help_option_arguments?(@argv[1..] || [])
           print_command_help("edit")
@@ -430,7 +446,8 @@ module Kward
     end
 
     def interactive_loop(agent: nil)
-      setup_interactive_prompt
+      setup_interactive_prompt(defer_warnings: true)
+      prepare_interactive_project_skills
       session_store = interactive_session_store(agent)
       @resumed_last_session = false
       if session_store && @prompt.respond_to?(:update_tabs)
@@ -450,8 +467,10 @@ module Kward
 
       print_visual_banner unless @resumed_last_session || @restored_tabs
       render_resumed_last_session_transcript(agent.conversation) if @resumed_last_session
+      enable_interactive_warnings if respond_to?(:enable_interactive_warnings, true)
 
       @pending_inputs = []
+      install_bang_completion_provider(agent)
 
       loop do
         if @pending_inputs.empty? && active_tab&.shell
@@ -543,6 +562,7 @@ module Kward
       runtime_output("Goodbye.")
       active_tab&.agent&.conversation || agent&.conversation
     ensure
+      clear_bang_completion_provider
       begin
         stop_tabs if respond_to?(:stop_tabs, true)
         @prompt.close if prompt_interface?

data/lib/kward/config_files.rb

@@ -917,8 +917,12 @@ module Kward
     # Lists configured skills discovered under the config directory.
     #
     # @return [Array<Skill>] skill metadata available to the model
-    def skills(workspace_root: Dir.pwd, warning_sink: nil)
-      skills_registry(workspace_root: workspace_root, warning_sink: warning_sink).skills
+    def skills(workspace_root: Dir.pwd, warning_sink: nil, project_skill_paths: nil)
+      skills_registry(workspace_root: workspace_root, warning_sink: warning_sink, project_skill_paths: project_skill_paths).skills
+    end
+
+    def project_skill_candidates(workspace_root: Dir.pwd, warning_sink: nil)
+      skills_registry(workspace_root: workspace_root, warning_sink: warning_sink).project_skill_candidates
     end
 
     # @return [String] trusted user plugin directory
@@ -961,7 +965,7 @@ module Kward
       skills_registry(workspace_root: workspace_root).read_skill_file(name, relative_path)
     end
 
-    def skills_registry(workspace_root: Dir.pwd, warning_sink: nil)
+    def skills_registry(workspace_root: Dir.pwd, warning_sink: nil, project_skill_paths: nil)
       Skills::Registry.new(
         config_dir: config_dir,
         workspace_root: workspace_root,
@@ -970,7 +974,8 @@ module Kward
         max_file_bytes: MAX_SKILL_FILE_BYTES,
         markdown_parser: ->(path) { Frontmatter.markdown_parts(path, lenient: true) },
         inside_directory: method(:inside_directory?),
-        warning_sink: warning_sink || @warning_sink
+        warning_sink: warning_sink || @warning_sink,
+        project_skill_paths: project_skill_paths
       )
     end