kward 0.75.0 → 0.77.0

data/templates/default/kward_navigation.rb

@@ -9,6 +9,7 @@ module KwardDocsNavigationData
         ["Usage", "file.usage.html"],
         ["Configuration", "file.configuration.html"],
         ["Authentication", "file.authentication.html"],
+        ["Security and trust", "file.security.html"],
         ["Troubleshooting", "file.troubleshooting.html"]
       ]
     ],
@@ -16,10 +17,12 @@ module KwardDocsNavigationData
       "Feature guides",
       [
         ["Sessions", "file.session-management.html"],
+        ["Interactive composer", "file.composer.html"],
         ["Tabs", "file.tabs.html"],
         ["Memory", "file.memory.html"],
         ["Personas", "file.personas.html"],
-        ["Skills", "file.skills.html"]
+        ["Skills", "file.skills.html"],
+        ["Pan mode", "file.pan.html"]
       ]
     ],
     [
@@ -45,6 +48,7 @@ module KwardDocsNavigationData
     [
       "Integrate",
       [
+        ["MCP servers", "file.mcp.html"],
         ["RPC protocol", "file.rpc.html"],
         ["Releasing", "file.releasing.html"]
       ]

data/templates/default/layout/html/layout.erb

@@ -110,7 +110,6 @@
           <article><strong>⌘</strong><h2>Project-aware agent loop</h2><p>Inspect, reason, patch, verify.</p></article>
           <article><strong>▤</strong><h2>Unix filter mode</h2><p>Pipe diffs, logs, and code through Kward.</p></article>
           <article><strong>▰</strong><h2>Branchable sessions</h2><p>Resume, rewind, fork, compact, export.</p></article>
-          <article><strong>›_</strong><h2>Worker pipelines</h2><p>Queue focused agent tasks from the TUI.</p></article>
           <article><strong>◎</strong><h2>Live source intelligence</h2><p>Search the web and read public repos.</p></article>
           <article><strong>✣</strong><h2>Ruby-native extensions</h2><p>Shape Kward with plugins, skills, and prompts.</p></article>
         </section>
@@ -137,7 +136,6 @@
             <li>Review diffs, stage files, and commit changes from the integrated Git workflow.</li>
             <li>Pipe diffs, logs, code, and generated text through Kward as a Unix filter.</li>
             <li>Organize long-running work with tabs, sessions, rewind, forks, compaction, and exports.</li>
-            <li>Dispatch worker tasks, leave them running, review the results later.</li>
             <li>Ground answers with live web search and public source repositories before guessing.</li>
             <li>Shape Kward with memory, skills, prompts, personas, and trusted Ruby plugins.</li>
             <li>Build custom UIs on top of Kward’s JSON-RPC backend.</li>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kward
 version: !ruby/object:Gem::Version
-  version: 0.75.0
+  version: 0.77.0
 platform: ruby
 authors:
 - Kai Wood
@@ -129,6 +129,7 @@ files:
 - doc/api.md
 - doc/authentication.md
 - doc/code-search.md
+- doc/composer.md
 - doc/configuration.md
 - doc/context-budgeting.md
 - doc/context-tools.md
@@ -140,10 +141,12 @@ files:
 - doc/lifecycle-hooks.md
 - doc/mcp.md
 - doc/memory.md
+- doc/pan.md
 - doc/personas.md
 - doc/plugins.md
 - doc/releasing.md
 - doc/rpc.md
+- doc/security.md
 - doc/session-management.md
 - doc/shell.md
 - doc/skills.md
@@ -234,6 +237,7 @@ files:
 - lib/kward/model/stream_parser.rb
 - lib/kward/openrouter_model_cache.rb
 - lib/kward/pan/index.html.erb
+- lib/kward/pan/kward_logo.png
 - lib/kward/pan/server.rb
 - lib/kward/path_guard.rb
 - lib/kward/plugin_registry.rb
@@ -348,17 +352,6 @@ files:
 - lib/kward/transcript_export.rb
 - lib/kward/update_check.rb
 - lib/kward/version.rb
-- lib/kward/workers.rb
-- lib/kward/workers/git_guard.rb
-- lib/kward/workers/job.rb
-- lib/kward/workers/live_view.rb
-- lib/kward/workers/manager.rb
-- lib/kward/workers/queue_runner.rb
-- lib/kward/workers/queue_store.rb
-- lib/kward/workers/store.rb
-- lib/kward/workers/tool_policy.rb
-- lib/kward/workers/worker.rb
-- lib/kward/workers/write_lock.rb
 - lib/kward/workspace.rb
 - lib/main.rb
 - templates/default/fulldoc/html/css/kward.css

data/lib/kward/workers/git_guard.rb

@@ -1,93 +0,0 @@
-require "open3"
-
-module Kward
-  module Workers
-    # Small git boundary used by write-lane workers to keep implementation work isolated.
-    class GitGuard
-      def initialize(root: Dir.pwd)
-        @root = root.to_s
-      end
-
-      def repository?
-        success?("rev-parse", "--is-inside-work-tree")
-      end
-
-      def clean?
-        return true unless repository?
-
-        status.empty?
-      end
-
-      def dirty?
-        !clean?
-      end
-
-      def status
-        run("status", "--porcelain").stdout
-      end
-
-      def head
-        result = run("rev-parse", "--verify", "HEAD")
-        result.success? ? result.stdout.strip : nil
-      end
-
-      def commit_all(message)
-        add = run("add", "-A")
-        return Result.new(success: false, stdout: add.stdout, stderr: add.stderr) unless add.success?
-
-        commit = run("commit", "-m", message)
-        return Result.new(success: false, stdout: commit.stdout, stderr: commit.stderr) unless commit.success?
-
-        Result.new(success: true, stdout: commit.stdout, stderr: commit.stderr, commit: head)
-      end
-
-      def stash(message)
-        before = stash_refs
-        result = run("stash", "push", "--include-untracked", "-m", message)
-        return Result.new(success: false, stdout: result.stdout, stderr: result.stderr) unless result.success?
-        return Result.new(success: true, stdout: result.stdout, stderr: result.stderr) if result.stdout.include?("No local changes")
-
-        ref = (stash_refs - before).first || stash_refs.first
-        Result.new(success: true, stdout: result.stdout, stderr: result.stderr, commit: ref)
-      end
-
-      def apply_stash(ref)
-        run("stash", "apply", ref.to_s)
-      end
-
-      def drop_stash(ref)
-        run("stash", "drop", ref.to_s)
-      end
-
-      private
-
-      Result = Struct.new(:success, :stdout, :stderr, :commit, keyword_init: true) do
-        def success?
-          success
-        end
-
-        def output
-          [stdout, stderr].compact.reject(&:empty?).join("\n")
-        end
-      end
-
-      def success?(*args)
-        run(*args).success?
-      end
-
-      def stash_refs
-        result = run("stash", "list", "--format=%gd")
-        return [] unless result.success?
-
-        result.stdout.lines.map(&:strip).reject(&:empty?)
-      end
-
-      def run(*args)
-        stdout, stderr, status = Open3.capture3("git", "-C", @root, *args)
-        Result.new(success: status.success?, stdout: stdout.to_s, stderr: stderr.to_s)
-      rescue Errno::ENOENT
-        Result.new(success: false, stdout: "", stderr: "git executable not found")
-      end
-    end
-  end
-end

data/lib/kward/workers/job.rb

@@ -1,99 +0,0 @@
-require "securerandom"
-require "time"
-require_relative "../config_files"
-
-module Kward
-  module Workers
-    # Persistent queue entry for a session-backed worker.
-    class Job
-      STATUSES = %w[queued running suspended ready_for_review failed blocked cancelled archived].freeze
-
-      def initialize(id: SecureRandom.hex(4), title:, session_path:, workspace_root: Dir.pwd, status: "queued", position: nil, commit_sha: nil, stash_ref: nil, error: nil, enqueued_at: Time.now.utc, started_at: nil, finished_at: nil, updated_at: nil)
-        @id = id.to_s
-        @title = title.to_s
-        @session_path = session_path.to_s
-        @workspace_root = ConfigFiles.canonical_workspace_root(workspace_root)
-        @status = status.to_s
-        @position = position
-        @commit_sha = commit_sha
-        @stash_ref = stash_ref
-        @error = error
-        @enqueued_at = enqueued_at
-        @started_at = started_at
-        @finished_at = finished_at
-        @updated_at = updated_at || enqueued_at
-      end
-
-      attr_reader :id, :title, :session_path, :workspace_root, :position, :commit_sha, :stash_ref, :error, :enqueued_at, :started_at, :finished_at, :updated_at
-
-      def status
-        @status
-      end
-
-      def update_status(status, commit_sha: nil, stash_ref: nil, error: nil, position: nil)
-        @status = status.to_s
-        @commit_sha = commit_sha unless commit_sha.nil?
-        @stash_ref = stash_ref unless stash_ref.nil?
-        @error = error unless error.nil?
-        @position = position unless position.nil?
-        now = Time.now.utc
-        @updated_at = now
-        @started_at ||= now if @status == "running"
-        @finished_at = now if %w[ready_for_review failed blocked cancelled archived].include?(@status)
-        self
-      end
-
-      def to_h
-        {
-          "id" => id,
-          "title" => title,
-          "session_path" => session_path,
-          "workspace_root" => workspace_root,
-          "status" => status,
-          "position" => position,
-          "commit_sha" => commit_sha,
-          "stash_ref" => stash_ref,
-          "error" => error,
-          "enqueued_at" => timestamp(enqueued_at),
-          "started_at" => timestamp(started_at),
-          "finished_at" => timestamp(finished_at),
-          "updated_at" => timestamp(updated_at)
-        }
-      end
-
-      def self.from_h(record)
-        new(
-          id: record.fetch("id"),
-          title: record.fetch("title"),
-          session_path: record.fetch("session_path"),
-          workspace_root: record["workspace_root"] || Dir.pwd,
-          status: record["status"] || "queued",
-          position: record["position"],
-          commit_sha: record["commit_sha"],
-          stash_ref: record["stash_ref"],
-          error: record["error"],
-          enqueued_at: parse_time(record["enqueued_at"]) || Time.now.utc,
-          started_at: parse_time(record["started_at"]),
-          finished_at: parse_time(record["finished_at"]),
-          updated_at: parse_time(record["updated_at"])
-        )
-      end
-
-      def self.parse_time(value)
-        return nil if value.to_s.empty?
-
-        Time.parse(value.to_s).utc
-      rescue ArgumentError
-        nil
-      end
-
-      private_class_method :parse_time
-
-      private
-
-      def timestamp(value)
-        value&.utc&.iso8601(3)
-      end
-    end
-  end
-end

data/lib/kward/workers/live_view.rb

@@ -1,49 +0,0 @@
-module Kward
-  module Workers
-    # Drains a running worker's accumulated event history into a frontend renderer.
-    class LiveView
-      FINISHED_STATUSES = %w[ready failed cancelled archived].freeze
-
-      def initialize(worker:, agent:, renderer:, poll_interval: 0.05)
-        @worker = worker
-        @agent = agent
-        @renderer = renderer
-        @poll_interval = poll_interval
-        @seen_events = worker.event_history.length
-        @stop = false
-        @thread = nil
-      end
-
-      attr_reader :worker, :agent
-
-      def start
-        @thread = Thread.new { run }
-        @thread.report_on_exception = false
-        self
-      end
-
-      def stop
-        @stop = true
-        @thread&.join(0.2)
-      end
-
-      private
-
-      def run
-        until @stop
-          events = @worker.event_history[@seen_events..] || []
-          events.each { |event| @renderer.call(event, @agent) }
-          @seen_events += events.length
-          @renderer.call(:flush, @agent) if finished?
-          break if finished?
-
-          sleep @poll_interval
-        end
-      end
-
-      def finished?
-        FINISHED_STATUSES.include?(@worker.status)
-      end
-    end
-  end
-end

data/lib/kward/workers/manager.rb

@@ -1,328 +0,0 @@
-require "timeout"
-require_relative "../agent"
-require_relative "../cancellation"
-require_relative "../conversation"
-require_relative "../hooks"
-require_relative "../model/client"
-require_relative "../session_store"
-require_relative "../tools/registry"
-require_relative "../workspace"
-require_relative "git_guard"
-require_relative "tool_policy"
-require_relative "worker"
-
-module Kward
-  module Workers
-    # Coordinates background worker execution and role-specific tool policy.
-    class Manager
-      DEFAULT_TIMEOUT_SECONDS = 180
-
-      def initialize(client_factory: -> { Client.new }, prompt: nil, workspace_root: Dir.pwd, timeout_seconds: DEFAULT_TIMEOUT_SECONDS, on_status_change: nil, session_store: nil, provider: nil, model: nil, reasoning_effort: nil, write_lock: nil, worker_store: nil, git_guard: nil, write_lane_available: -> { true }, hook_manager: nil, hook_context: nil)
-        @client_factory = client_factory
-        @prompt = prompt
-        @workspace_root = ConfigFiles.canonical_workspace_root(workspace_root)
-        @timeout_seconds = timeout_seconds
-        @on_status_change = on_status_change
-        @session_store = session_store
-        @provider = provider
-        @model = model
-        @reasoning_effort = reasoning_effort
-        @write_lock = write_lock
-        @worker_store = worker_store
-        @git_guard = git_guard || GitGuard.new(root: @workspace_root)
-        @write_lane_available = write_lane_available
-        @hook_manager = hook_manager
-        @hook_context = hook_context
-        @workers = {}
-        @mutex = Mutex.new
-      end
-
-      def start(role:, prompt:, title: nil, id: nil)
-        worker = build_worker(role: role, prompt: prompt, title: title, id: id)
-        run_blocking_hook("worker_job_create", worker)
-        enqueue(worker)
-      end
-
-      def continue(id, role:, prompt:, title: nil)
-        archived = nil
-        worker = build_worker(role: role, prompt: prompt, title: title, id: id)
-        @mutex.synchronize do
-          archived = @workers.delete(id.to_s)
-          @workers[worker.id] = worker
-        end
-        archived&.update_status("archived")
-        @worker_store&.archive(id) if archived || @worker_store&.find(id)
-        enqueue(worker, store: false)
-      end
-
-      def list
-        @mutex.synchronize { @workers.values.reject { |worker| worker.status == "archived" }.sort_by(&:created_at) }
-      end
-
-      def find(id)
-        @mutex.synchronize { @workers[id.to_s] }
-      end
-
-      def cancel(id)
-        worker = find(id) || raise(ArgumentError, "Unknown worker: #{id}")
-        worker.cancellation.cancel!
-        worker.thread.raise(Cancellation::CancelledError, "cancelled") if worker.thread&.alive?
-        update_status(worker, "cancelled")
-      end
-
-      def archive(id)
-        worker = find(id) || raise(ArgumentError, "Unknown worker: #{id}")
-        worker.cancellation.cancel! if %w[queued running].include?(worker.status)
-        worker.thread.raise(Cancellation::CancelledError, "cancelled") if worker.thread&.alive?
-        update_status(worker, "archived")
-      end
-
-      private
-
-      def build_worker(role:, prompt:, title: nil, id: nil)
-        Worker.new(
-          id: id || SecureRandom.hex(4),
-          title: title || title_for(prompt),
-          role: role,
-          prompt: prompt,
-          workspace_root: @workspace_root,
-          status: "queued"
-        )
-      end
-
-      def enqueue(worker, store: true)
-        @mutex.synchronize { @workers[worker.id] = worker }
-        @worker_store&.upsert(worker) if store
-        worker.thread = Thread.new { run_worker(worker) }
-        worker.thread.report_on_exception = false
-        worker
-      end
-
-      def run_worker(worker)
-        conversation = Conversation.new(
-          system_message: { role: "system", content: system_message(worker) },
-          workspace_root: worker.workspace_root,
-          provider: @provider,
-          model: @model,
-          reasoning_effort: @reasoning_effort
-        )
-        worker.conversation = conversation
-        attach_session(worker, conversation)
-        writer_id = wait_for_worker_writer(worker)
-        run_blocking_hook("worker_job_start_before", worker)
-        update_status(worker, "running")
-        run_hook("worker_job_start_after", worker)
-        registry = ToolRegistry.new(
-          workspace: Workspace.new(root: worker.workspace_root),
-          prompt: @prompt,
-          allowed_tool_names: ToolPolicy.allowed_tool_names(worker.role),
-          write_lock: @write_lock,
-          writer_id: writer_id,
-          hook_manager: @hook_manager,
-          hook_context: @hook_context
-        )
-        agent = Agent.new(client: @client_factory.call, tool_registry: registry, conversation: conversation, hook_manager: @hook_manager, hook_context: @hook_context)
-        report = Timeout.timeout(@timeout_seconds, WorkerTimeoutError) do
-          agent.ask(worker_prompt(worker), cancellation: worker.cancellation) do |event|
-            worker.record_event(event)
-          end
-        end
-        report = finalize_write_worker(worker, report)
-        update_status(worker, "ready", report: report, error: "")
-        run_hook("worker_job_ready_for_review", worker)
-      rescue WorkerTimeoutError
-        update_status(worker, "failed", error: "Worker timed out after #{@timeout_seconds} seconds")
-        run_hook("worker_job_failed", worker, error: "Worker timed out after #{@timeout_seconds} seconds")
-      rescue Cancellation::CancelledError
-        update_status(worker, "cancelled")
-      rescue StandardError => e
-        update_status(worker, "failed", error: e.message)
-        run_hook("worker_job_failed", worker, error: e.message)
-      ensure
-        release_worker_writer(worker)
-      end
-
-      def run_blocking_hook(name, worker, payload = {})
-        result = run_hook(name, worker, payload)
-        return result unless result && !result.allowed?
-
-        raise HookDenied, result.decision.message || "Worker lifecycle hook #{name} blocked the job"
-      end
-
-      def run_hook(name, worker, payload = {})
-        return unless @hook_manager
-
-        @hook_manager.run(Hooks::Event.new(
-          name: name,
-          workspace: { root: worker.workspace_root },
-          payload: worker_payload(worker).merge(payload)
-        ), context: @hook_context)
-      end
-
-      HookDenied = Class.new(StandardError)
-
-      def worker_payload(worker)
-        {
-          worker_id: worker.id,
-          role: worker.role,
-          title: worker.title,
-          status: worker.status,
-          session_path: worker.session&.path
-        }.compact
-      end
-
-      def update_status(worker, status, **values)
-        return worker if worker.status == "archived" && status.to_s != "archived"
-
-        worker.update_status(status, **values)
-        @worker_store&.upsert(worker)
-        @on_status_change&.call(worker)
-        worker
-      end
-
-      def wait_for_worker_writer(worker)
-        return nil unless ToolPolicy.write_capable?(worker.role)
-
-        loop do
-          worker.cancellation.raise_if_cancelled!
-          wait_for_write_lane_available(worker)
-          wait_for_clean_workspace(worker)
-          return worker.id unless @write_lock
-
-          release_foreground_writer_if_clean
-          return worker.id if @write_lock.acquire(worker.id)
-
-          sleep 0.1
-        end
-      end
-
-      def wait_for_write_lane_available(worker)
-        until @write_lane_available.call
-          worker.cancellation.raise_if_cancelled!
-          sleep 0.1
-        end
-      end
-
-      def wait_for_clean_workspace(worker)
-        return unless @git_guard.repository?
-
-        until @git_guard.clean?
-          worker.cancellation.raise_if_cancelled!
-          sleep 0.5
-        end
-      end
-
-      def release_foreground_writer_if_clean
-        return unless @write_lock&.owned_by?("implementation")
-        return unless @git_guard.repository?
-        return unless @git_guard.clean?
-
-        @write_lock.release("implementation")
-      end
-
-      def finalize_write_worker(worker, report)
-        return report unless ToolPolicy.write_capable?(worker.role)
-        return report unless @git_guard.repository?
-        return report if @git_guard.clean?
-
-        commit = @git_guard.commit_all(commit_message(worker))
-        unless commit.success?
-          raise "Worker changed files but commit failed: #{commit.output}"
-        end
-
-        [report, "", "Committed workspace changes: #{commit.commit}"].join("\n")
-      end
-
-      def commit_message(worker)
-        "Kward worker #{worker.id}: #{worker.title}"
-      end
-
-      def release_worker_writer(worker)
-        return unless ToolPolicy.write_capable?(worker.role)
-
-        @write_lock&.release(worker.id)
-      end
-
-      def attach_session(worker, conversation)
-        return unless @session_store
-
-        session = @session_store.create(provider: @provider, model: @model, reasoning_effort: @reasoning_effort)
-        session.rename("#{worker.role}: #{worker.title}")
-        session.attach(conversation)
-        worker.session = session
-        @worker_store&.upsert(worker)
-        @on_status_change&.call(worker)
-      rescue StandardError
-        nil
-      end
-
-      def worker_prompt(worker)
-        return request_prompt(worker.prompt) if worker.role == "request"
-
-        worker.prompt
-      end
-
-      def system_message(worker)
-        return request_system_message if worker.role == "request"
-
-        "You are a Kward worker. Complete the user's task carefully."
-      end
-
-      def request_system_message
-        <<~SYSTEM
-          You are a Kward request worker running the read-only exploration phase.
-          Inspect the workspace, map relevant terrain, and produce a practical review for the user.
-          Do not edit files, write files, delete files, alter configuration, or claim implementation work was done.
-        SYSTEM
-      end
-
-      def request_prompt(prompt)
-        <<~PROMPT
-          #{prompt}
-
-          ---
-
-          You are handling this as a structured Kward background request.
-          First perform a read-only exploration phase. Inspect relevant files and documentation, reason about the request, and prepare a reviewable result for the user.
-          Do not modify files, write files, delete files, alter configuration, run destructive commands, or claim implementation work was done.
-
-          Return a concise request review with these sections:
-          # Request Review: <title>
-
-          ## Request
-          Restate the user's request.
-
-          ## Summary
-          The short answer.
-
-          ## Relevant files
-          Bullet list of likely files and why they matter.
-
-          ## Findings
-          What you discovered.
-
-          ## Recommended next step
-          A practical next step. If implementation appears useful, say so clearly, but do not implement it.
-
-          ## Risks
-          Important risks or unknowns.
-
-          ## Verification
-          Focused verification commands or checks.
-
-          ## Open questions
-          Decisions the user should make before proceeding.
-
-          End by asking: Should we proceed?
-        PROMPT
-      end
-
-      def title_for(prompt)
-        text = prompt.to_s.strip.gsub(/\s+/, " ")
-        text.empty? ? "Untitled worker" : text[0, 80]
-      end
-
-      class WorkerTimeoutError < StandardError; end
-    end
-  end
-end