rubik 0.3.3 → 0.3.5

data/lib/rubik/lsp/manager.rb

@@ -29,8 +29,18 @@ module Rubik
         ".vue" => "vue"
       }.freeze
 
+      DOCUMENT_LANGUAGE_ID_MAP = {
+        ".cpp" => "cpp",
+        ".hpp" => "cpp",
+        ".tsx" => "typescriptreact",
+        ".jsx" => "javascriptreact",
+        ".sh" => "shellscript",
+        ".bash" => "shellscript"
+      }.freeze
+
       MAX_CONSECUTIVE_CRASHES = 3
       CIRCUIT_COOLDOWN_SECONDS = 300
+      CIRCUIT_STABILITY_SECONDS = 60
 
       attr_reader :config, :root_dir, :clients, :crash_stats
       attr_accessor :runtime_manager, :context
@@ -42,6 +52,7 @@ module Rubik
         @context = context || runtime_manager&.context
         @clients = {}
         @crash_stats = {}
+        @healthy_since = {}
         @recovery_errors = {}
         @registered_disposable_langs = {}
         @monitor = Monitor.new
@@ -60,12 +71,24 @@ module Rubik
         EXTENSION_MAP[ext]
       end
 
+      def document_language_id(file_path)
+        ext = File.extname(file_path).downcase
+        DOCUMENT_LANGUAGE_ID_MAP[ext] || detect_language(file_path) || "plaintext"
+      end
+
       def circuit_open?(lang)
         @monitor.synchronize do
           stat = @crash_stats[lang.to_s.downcase]
+          healthy_since = @healthy_since[lang.to_s.downcase]
+          if healthy_since && monotonic_now - healthy_since >= CIRCUIT_STABILITY_SECONDS
+            @crash_stats.delete(lang.to_s.downcase)
+            @healthy_since.delete(lang.to_s.downcase)
+            return false
+          end
+
           return false unless stat && stat[:circuit_open]
 
-          if stat[:last_crash_at] && (Time.now - stat[:last_crash_at] > CIRCUIT_COOLDOWN_SECONDS)
+          if stat[:last_crash_at] && (monotonic_now - stat[:last_crash_at] > CIRCUIT_COOLDOWN_SECONDS)
             stat[:circuit_open] = false
             stat[:count] = 0
             false
@@ -78,9 +101,11 @@ module Rubik
       def record_crash(lang)
         @monitor.synchronize do
           lang_str = lang.to_s.downcase
+          healthy_since = @healthy_since.delete(lang_str)
+          @crash_stats.delete(lang_str) if healthy_since && monotonic_now - healthy_since >= CIRCUIT_STABILITY_SECONDS
           stat = (@crash_stats[lang_str] ||= { count: 0, last_crash_at: nil, circuit_open: false })
           stat[:count] += 1
-          stat[:last_crash_at] = Time.now
+          stat[:last_crash_at] = monotonic_now
           stat[:circuit_open] = true if stat[:count] >= MAX_CONSECUTIVE_CRASHES
         end
       end
@@ -89,6 +114,7 @@ module Rubik
         @monitor.synchronize do
           lang_str = lang.to_s.downcase
           @crash_stats.delete(lang_str)
+          @healthy_since[lang_str] = monotonic_now
         end
       end
 
@@ -125,13 +151,13 @@ module Rubik
 
           unless client.available?
             failure = Runtime::DiagnosticEngine.diagnose(
-              cmd: client.server_cmd,
+              cmd: ServerCommand.display(client.server_cmd),
               exit_code: 127,
-              stderr: "Server binary '#{client.server_cmd}' not found in PATH"
+              stderr: "Server binary '#{ServerCommand.display(client.server_cmd)}' not found in PATH"
             )
             return {
               ok: false,
-              error: "Server binary '#{client.server_cmd}' not found",
+              error: "Server binary '#{ServerCommand.display(client.server_cmd)}' not found",
               diagnostic: failure,
               suggestion: failure.suggestion
             }
@@ -146,12 +172,12 @@ module Rubik
               reset_circuit!(lang_str)
               @recovery_errors.delete(lang_str)
               register_client_unlocked(lang_str, client)
-              { ok: true, message: "Started LSP server for '#{lang_str}' (#{client.server_cmd})" }
+              { ok: true, message: "Started LSP server for '#{lang_str}' (#{ServerCommand.display(client.server_cmd)})" }
             else
               record_crash(lang_str)
               stop_client_safely(client)
               failure = Runtime::DiagnosticEngine.diagnose(
-                cmd: client.server_cmd,
+                cmd: ServerCommand.display(client.server_cmd),
                 exit_code: 1,
                 stderr: "Failed to initialize LSP server handshake for '#{lang_str}'"
               )
@@ -201,10 +227,19 @@ module Rubik
         if client.document_open?(file_path)
           client.did_change(file_path, content)
         else
-          client.did_open(file_path, content)
+          client.did_open(file_path, content, document_language_id(file_path))
         end
       end
 
+      def did_save_file(file_path, content = nil)
+        return false unless enabled?
+
+        client = client_for(file_path)
+        return false unless client&.running
+
+        client.did_save(file_path, content)
+      end
+
       def sync_buffer_file_if_needed(file_path, buffer_manager)
         return false unless enabled? && buffer_manager
 
@@ -242,6 +277,20 @@ module Rubik
         client.diagnostics_for(file_path)
       end
 
+      def diagnostics_snapshot_for(file_path)
+        client = client_for(file_path)
+        return { state: :unavailable, diagnostics: [], document_version: nil, published_version: nil } unless client&.running
+
+        client.diagnostics_snapshot_for(file_path)
+      end
+
+      def wait_for_diagnostics(file_path, timeout: 0.2)
+        client = client_for(file_path)
+        return { state: :unavailable, diagnostics: [], document_version: nil, published_version: nil } unless client&.running
+
+        client.wait_for_diagnostics(file_path, timeout: timeout)
+      end
+
       def all_diagnostics
         result = {}
         @monitor.synchronize do
@@ -254,6 +303,18 @@ module Rubik
         result
       end
 
+      def all_diagnostic_snapshots
+        result = {}
+        @monitor.synchronize do
+          @clients.each_value do |client|
+            next unless client.running
+
+            result.merge!(client.all_diagnostic_snapshots)
+          end
+        end
+        result
+      end
+
       def hover(file_path, line, character)
         client = client_for(file_path)
         return { ok: false, error: inactive_client_error(file_path, client) } unless client&.running
@@ -285,11 +346,12 @@ module Rubik
             probed = avail ? cmd : Runtime::Discovery.probe_lsp(lang, root_dir: @root_dir)
 
             client_statuses[lang] = {
-              server_cmd: cmd,
+              server_cmd: ServerCommand.display(cmd),
               probed_cmd: probed,
               available: avail || !probed.nil?,
               running: active_c&.running || false,
-              diagnostics_count: active_c ? active_c.all_diagnostics.values.flatten.size : 0
+              diagnostics_count: active_c ? active_c.all_diagnostics.values.flatten.size : 0,
+              diagnostics_pending_count: active_c ? active_c.all_diagnostic_snapshots.values.count { |s| s[:state] == :pending } : 0
             }
           end
         end
@@ -316,6 +378,7 @@ module Rubik
       # Caller MUST hold @monitor. Dead-client removal and replacement startup
       # happen in one critical section so concurrent requests share one client.
       def client_for_unlocked(lang, preferred = nil)
+        circuit_open?(lang) # also retires crash history after sustained healthy operation
         stored = @clients[lang]
         client = stored || preferred
         recovering = false
@@ -349,7 +412,7 @@ module Rubik
 
           if client.available? && @config.fetch("lsp.auto_start", true) && !circuit_open?(lang)
             if client.start
-              reset_circuit!(lang)
+              note_healthy_start(lang)
               @recovery_errors.delete(lang)
               register_client_unlocked(lang, client)
             else
@@ -370,7 +433,7 @@ module Rubik
         elsif !client.running && @config.fetch("lsp.auto_start", true) &&
               client.available? && !circuit_open?(lang)
           if client.start
-            reset_circuit!(lang)
+            note_healthy_start(lang)
             @recovery_errors.delete(lang)
             register_client_unlocked(lang, client)
           else
@@ -408,6 +471,14 @@ module Rubik
         nil
       end
 
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def note_healthy_start(lang)
+        @healthy_since[lang.to_s.downcase] = monotonic_now
+      end
+
       def inactive_client_error(file_path, client)
         lang = client&.language || detect_language(file_path)
         @monitor.synchronize do

data/lib/rubik/lsp/server_command.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative "../platform"
+
+module Rubik
+  module LSP
+    # Converts configured LSP commands to argv without invoking a shell.
+    # Structured commands are portable; legacy strings use the native
+    # platform's command-line quoting rules.
+    module ServerCommand
+      module_function
+
+      def argv(command)
+        parts = case command
+                when Hash
+                  executable = command["executable"] || command[:executable]
+                  args = command["args"] || command[:args] || []
+                  raise ArgumentError, "LSP command executable must be a non-empty string" unless executable.is_a?(String) && !executable.strip.empty?
+                  raise ArgumentError, "LSP command args must be an array" unless args.is_a?(Array)
+                  raise ArgumentError, "LSP command args must contain only strings" unless args.all?(String)
+
+                  [executable, *args]
+                when Array
+                  raise ArgumentError, "LSP argv must contain only strings" unless command.all?(String)
+
+                  command
+                when String
+                  Rubik::Platform.windows? ? split_windows(command) : Shellwords.shellsplit(command)
+                else
+                  []
+                end
+
+        parts = parts.map(&:to_s)
+        return [] if parts.empty? || parts.first.to_s.strip.empty?
+        raise ArgumentError, "LSP command arguments cannot be nil" if parts.any?(&:empty?)
+
+        parts
+      rescue ArgumentError => e
+        raise ArgumentError, "Invalid LSP server command: #{e.message}"
+      end
+
+      def display(command)
+        argv(command).join(" ")
+      rescue ArgumentError
+        command.to_s
+      end
+
+      # Implements the Windows command-line quoting rules used by
+      # CommandLineToArgvW: backslashes only escape quotes when immediately
+      # preceding one; whitespace separates arguments outside quotes.
+      def split_windows(command)
+        args = []
+        arg = +""
+        arg_started = false
+        quote_char = nil
+        i = 0
+
+        while i < command.length
+          if command[i] == "\\" && quote_char != "'"
+            start = i
+            i += 1 while command[i] == "\\"
+            slashes = i - start
+            arg_started = true
+            if command[i] == '"'
+              arg << ("\\" * (slashes / 2))
+              if slashes.odd?
+                arg << '"'
+              else
+                quote_char = quote_char == '"' ? nil : '"'
+              end
+              i += 1
+            else
+              arg << ("\\" * slashes)
+            end
+          elsif ['"', "'"].include?(command[i]) && (quote_char.nil? || quote_char == command[i])
+            arg_started = true
+            quote_char = quote_char ? nil : command[i]
+            i += 1
+          elsif command[i] =~ /\s/ && quote_char.nil?
+            if arg_started
+              args << arg
+              arg = +""
+              arg_started = false
+            end
+            i += 1 while command[i] =~ /\s/
+          else
+            arg_started = true
+            arg << command[i]
+            i += 1
+          end
+        end
+
+        raise ArgumentError, "unmatched quote" if quote_char
+
+        args << arg if arg_started
+        args
+      end
+      private_class_method :split_windows
+    end
+  end
+end

data/lib/rubik/orchestrator/goal_ledger/patch.rb

@@ -121,81 +121,98 @@ module Rubik
         end
 
         def self.normalize_op(raw, idx)
-          return [nil, [op_shape_reason(idx)]] unless raw.is_a?(Hash)
+          err = validate_op_keys(raw, idx)
+          return [nil, [err]] if err
+
+          verb, path, err = validate_op_verb_and_path(raw, idx)
+          return [nil, [err]] if err
+
+          tokens, err = tokenize(path, idx)
+          return [nil, [err]] if err
+
+          err = validate_op_value_and_hyphen(raw, verb, path, tokens, idx)
+          return [nil, [err]] if err
+
+          value = verb == "remove" ? nil : deep_freeze(raw["value"])
+          [{ op: verb.to_sym, path: path, tokens: tokens, value: value, index: idx }.freeze, []]
+        end
+
+        def self.validate_op_keys(raw, idx)
+          return op_shape_reason(idx) unless raw.is_a?(Hash)
 
           unknown = raw.keys - OP_KEYS
-          unless unknown.empty?
-            return [nil, [GoalLedger.reason(
-              :schema, op_index: idx, path: "",
-                       message: "op #{idx} carries unknown key(s) #{unknown.join(', ')}",
-                       hint: "allowed op keys: op, path, value"
-            )]]
-          end
+          return nil if unknown.empty?
+
+          GoalLedger.reason(
+            :schema, op_index: idx, path: "",
+                     message: "op #{idx} carries unknown key(s) #{unknown.join(', ')}",
+                     hint: "allowed op keys: op, path, value"
+          )
+        end
 
+        def self.validate_op_verb_and_path(raw, idx)
           verb = raw["op"]
           unless OP_VERBS.include?(verb)
-            return [nil, [GoalLedger.reason(
+            return nil, nil, GoalLedger.reason(
               :schema, op_index: idx, path: "",
                        message: "op #{idx} has unknown verb #{GoalLedger.json_type_name(verb)}#{verb_inspect(verb)}",
                        hint: "allowed verbs: add, replace, remove"
-            )]]
+            )
           end
 
           path = raw["path"]
           unless path.is_a?(String)
-            return [nil, [GoalLedger.reason(
+            return nil, nil, GoalLedger.reason(
               :schema, op_index: idx, path: "",
                        message: "op #{idx} path must be a JSON string (got #{GoalLedger.json_type_name(path)})",
                        hint: 'address sections with JSON pointers like "/tasks/3/status" or "/findings/-"'
-            )]]
+            )
           end
 
           unless path.start_with?("/")
-            return [nil, [GoalLedger.reason(
+            return nil, nil, GoalLedger.reason(
               :schema, op_index: idx, path: path,
                        message: "op #{idx} path '#{path}' is not a JSON pointer",
                        hint: 'pointers start with "/" — use /section, /section/idx, /section/idx/field or /section/-'
-            )]]
+            )
           end
 
           if path == "/"
-            return [nil, [GoalLedger.reason(
+            return nil, nil, GoalLedger.reason(
               :schema, op_index: idx, path: path,
                        message: "op #{idx} addresses the whole ledger root",
-                       hint: "the ledger root is not replaceable; address sections individually " \
-                             "(/tasks/3/status, /findings/-, ...)"
-            )]]
+                       hint: "the ledger root is not replaceable; address sections individually (/tasks/3/status, /findings/-, ...)"
+            )
           end
 
-          tokens, err = tokenize(path, idx)
-          return [nil, [err]] if err
+          [verb, path, nil]
+        end
 
+        def self.validate_op_value_and_hyphen(raw, verb, path, tokens, idx)
           if verb == "remove" && raw.key?("value")
-            return [nil, [GoalLedger.reason(
+            return GoalLedger.reason(
               :schema, op_index: idx, path: path,
                        message: "op #{idx} (remove) must not carry a value",
                        hint: "to change a value use replace; remove deletes the item outright"
-            )]]
+            )
           end
           unless verb == "remove" || raw.key?("value")
-            return [nil, [GoalLedger.reason(
+            return GoalLedger.reason(
               :schema, op_index: idx, path: path,
                        message: "op #{idx} (#{verb}) is missing its value",
                        hint: 'carry the value in the op: {"op": "add", "path": "/findings/-", "value": ...}'
-            )]]
+            )
           end
 
           if hyphen_violation(tokens, verb)
-            return [nil, [GoalLedger.reason(
+            return GoalLedger.reason(
               :schema, op_index: idx, path: path,
                        message: "op #{idx} path '#{path}' uses '-' outside an append position",
-                       hint: "'-' appends and may only be the final token of an add path " \
-                             "(e.g. /findings/-); use a numeric index for existing items"
-            )]]
+                       hint: "'-' appends and may only be the final token of an add path (e.g. /findings/-); use a numeric index for existing items"
+            )
           end
 
-          value = verb == "remove" ? nil : deep_freeze(raw["value"])
-          [{ op: verb.to_sym, path: path, tokens: tokens, value: value, index: idx }.freeze, []]
+          nil
         end
 
         def self.op_shape_reason(idx)
@@ -261,6 +278,7 @@ module Rubik
         end
 
         private_class_method :header_reasons, :normalize_op, :op_shape_reason, :verb_inspect,
+                             :validate_op_keys, :validate_op_verb_and_path, :validate_op_value_and_hyphen,
                              :tokenize, :hyphen_violation, :deep_freeze
       end
     end

data/lib/rubik/orchestrator/lsp_feedback.rb

@@ -36,17 +36,33 @@ module Rubik
       end
 
       def append_diagnostics(deps, written_file, tool_result)
-        sleep 0.05
-        diags = deps.lsp_manager.diagnostics_for(written_file)
+        snapshot = if deps.lsp_manager.respond_to?(:wait_for_diagnostics)
+                     deps.lsp_manager.wait_for_diagnostics(written_file, timeout: 0.2)
+                   else
+                     deps.lsp_manager.diagnostics_snapshot_for(written_file)
+                   end
+        return append_message(tool_result, "\n\n⏳ LSP diagnostics are pending for '#{written_file}'; no clean result is available yet.") if snapshot[:state] == :pending
+        return append_message(tool_result, "\n\nℹ️ LSP diagnostics are not available for '#{written_file}'.") if snapshot[:state] == :unavailable
+
+        diags = snapshot[:diagnostics]
         errors = diags.select { |d| d["severity"] == 1 }
-        return tool_result if errors.empty?
+        if errors.empty?
+          return tool_result if snapshot[:state] == :fresh
+
+          return append_message(tool_result, "\n\nℹ️ LSP returned no errors for '#{written_file}', but omitted the document version; freshness is unverified.")
+        end
 
         err_lines = errors.map { |e| "  • Line #{(e.dig('range', 'start', 'line') || 0) + 1}: #{e['message']}" }.join("\n")
         lsp_msg = "\n\n⚠️ [LSP Real-Time Compiler Diagnostics - #{errors.size} error(s)]:\n#{err_lines}\n" \
                   "Please fix these compilation/type errors before proceeding."
+        lsp_msg = "\n\nℹ️ LSP omitted the document version; diagnostic freshness is unverified.#{lsp_msg}" if snapshot[:state] == :unversioned
+        append_message(tool_result, lsp_msg)
+      end
+
+      def append_message(tool_result, message)
         Rubik::Tools::Result.new(
           tool_name: tool_result.tool_name, call_id: tool_result.call_id, status: tool_result.status,
-          output: "#{tool_result.output}#{lsp_msg}", duration_ms: tool_result.duration_ms,
+          output: "#{tool_result.output}#{message}", duration_ms: tool_result.duration_ms,
           truncated: tool_result.truncated
         )
       end

data/lib/rubik/orchestrator/subagent/reuse.rb

@@ -114,8 +114,8 @@ module Rubik
             @instances[inst.id] = inst
             activate_instance!(inst, child_ctx: child_ctx, owner_token: eff_owner)
           end
-          # SS bırakma kancası: redeploy da bir başlangıçtır — taze :running
-          # flip'i, bu id'yi SS ile bekleyen kuyruk spesifikasyonlarını
+          # Start-to-Start (SS) bırakma kancası: redeploy da bir başlangıçtır — taze :running
+          # flip'i, bu id'yi Start-to-Start (SS) ile bekleyen kuyruk spesifikasyonlarını
           # bırakır (kilit DIŞINDA — emit kuralı; spawn ile aynı düzen).
           release_ready!
           redeployed

data/lib/rubik/orchestrator/subagent/spawn_transaction.rb

@@ -20,10 +20,7 @@ module Rubik
         def spawn(role:, prompt:, type_name: "research", system_prompt: nil,
                   parent_id: ConversationId::ROOT_ID, workspace: "inherit", model: "inherit",
                   max_steps: nil, provider: nil, depends_on: nil, reserved_id: nil, owner: nil)
-          role_str = role.to_s.strip
-          prompt_str = prompt.to_s.strip
-          raise ArgumentError, "Subagent role cannot be empty" if role_str.empty?
-          raise ArgumentError, "Subagent prompt cannot be empty" if prompt_str.empty?
+          role_str, prompt_str = validate_spawn_args!(role, prompt)
 
           # Issue #125: the owner's task was cancelled — refuse before any
           # reservation, slot or context work happens.
@@ -44,7 +41,6 @@ module Rubik
 
             profile_snapshot = resolve_profile_snapshot(type_name: type_name, role: role_str,
                                                         system_prompt: system_prompt)
-            effective_sys_prompt = profile_snapshot.effective_system_prompt
             # A profile update must not redirect rollback to a newly provided
             # init supervisor after this spawn registered its unit.
             activation_init = init_for_activation
@@ -52,40 +48,23 @@ module Rubik
             # unchanged built-in prompt can be reconstructed from its type.
             prompt_reconstructible = system_prompt.to_s.strip.empty? && !profile_snapshot.custom_prompt
 
-            # Queued specs already reserved this id; fresh spawns reserve the
-            # next sequence number here and return it if activation rolls back.
-            generated_id = reserved_id.nil?
-            subagent_id = generated_id ? "subagent-#{@counter + 1}" : reserved_id.to_s
-            id_in_use = @instances.key?(subagent_id) || (@finished || {}).key?(subagent_id)
-            raise ArgumentError, "Subagent id '#{subagent_id}' is already in use." if id_in_use
-
-            @counter += 1 if generated_id
+            subagent_id, generated_id = reserve_subagent_id!(reserved_id)
 
             child_ctx = nil
             inst = nil
             begin
               child_ctx = extend_root_context!(:spawn)
-              effective_buffer = branch_or_inherit_buffer(workspace)
-              scoped_registry = build_scoped_registry(profile_snapshot, child_ctx, effective_buffer)
-              prov, effective_model = resolve_provider_and_model(model)
-              prov = provider if provider
-
-              inst = Instance.new(
-                id: subagent_id, parent_id: parent_id, role: role_str, type_name: profile_snapshot.name,
-                prompt: prompt_str, system_prompt: effective_sys_prompt, workspace: workspace,
-                model: effective_model, context: child_ctx, tool_registry: scoped_registry,
-                provider: prov, buffer_manager: effective_buffer, max_steps: (max_steps || @default_max_steps).to_i,
-                provider_gate: @provider_gate, root_dir: @root_dir, config: @config,
-                context_limit: (@config.respond_to?(:fetch) ? @config.fetch("context.max_tokens", 32_768) : 32_768),
-                event_bus: @event_bus, transcript_storage: absorb_storage, owner_task: owner,
-                prompt_reconstructible: prompt_reconstructible, profile_snapshot: profile_snapshot
+              inst = build_subagent_instance(
+                subagent_id: subagent_id, parent_id: parent_id, role_str: role_str, prompt_str: prompt_str,
+                profile_snapshot: profile_snapshot, workspace: workspace, model: model, max_steps: max_steps,
+                provider: provider, owner: owner, prompt_reconstructible: prompt_reconstructible,
+                child_ctx: child_ctx
               )
-
               @instances[subagent_id] = inst
-              activate_instance!(inst, child_ctx: child_ctx, owner_token: owner,
-                                       init_supervisor: activation_init, defer_start: true)
-              raise "Subagent worker start gate could not be released." unless inst.release_start!
 
+              activate_and_release_subagent!(
+                inst: inst, child_ctx: child_ctx, owner: owner, activation_init: activation_init
+              )
               inst
             rescue StandardError
               rollback_spawn!(subagent_id: subagent_id, inst: inst, child_ctx: child_ctx,
@@ -93,6 +72,7 @@ module Rubik
               raise
             end
           end
+
           # SS bırakma kancası: yeni başlayan instance, onu bekleyen kuyruk
           # spesifikasyonlarını serbest bırakır (kilit DIŞINDA — emit kuralı).
           begin
@@ -105,6 +85,55 @@ module Rubik
 
         private
 
+        def validate_spawn_args!(role, prompt)
+          role_str = role.to_s.strip
+          prompt_str = prompt.to_s.strip
+          raise ArgumentError, "Subagent role cannot be empty" if role_str.empty?
+          raise ArgumentError, "Subagent prompt cannot be empty" if prompt_str.empty?
+
+          [role_str, prompt_str]
+        end
+
+        def reserve_subagent_id!(reserved_id)
+          # Queued specs already reserved this id; fresh spawns reserve the
+          # next sequence number here and return it if activation rolls back.
+          generated_id = reserved_id.nil?
+          subagent_id = generated_id ? "subagent-#{@counter + 1}" : reserved_id.to_s
+          id_in_use = @instances.key?(subagent_id) || (@finished || {}).key?(subagent_id)
+          raise ArgumentError, "Subagent id '#{subagent_id}' is already in use." if id_in_use
+
+          @counter += 1 if generated_id
+          [subagent_id, generated_id]
+        end
+
+        def build_subagent_instance(subagent_id:, parent_id:, role_str:, prompt_str:,
+                                    profile_snapshot:, workspace:, model:, max_steps:,
+                                    provider:, owner:, prompt_reconstructible:, child_ctx:)
+          effective_buffer = branch_or_inherit_buffer(workspace)
+          scoped_registry = build_scoped_registry(profile_snapshot, child_ctx, effective_buffer)
+          prov, effective_model = resolve_provider_and_model(model)
+          prov = provider if provider
+
+          context_limit = @config.respond_to?(:fetch) ? @config.fetch("context.max_tokens", 32_768) : 32_768
+
+          Instance.new(
+            id: subagent_id, parent_id: parent_id, role: role_str, type_name: profile_snapshot.name,
+            prompt: prompt_str, system_prompt: profile_snapshot.effective_system_prompt, workspace: workspace,
+            model: effective_model, context: child_ctx, tool_registry: scoped_registry,
+            provider: prov, buffer_manager: effective_buffer, max_steps: (max_steps || @default_max_steps).to_i,
+            provider_gate: @provider_gate, root_dir: @root_dir, config: @config,
+            context_limit: context_limit, event_bus: @event_bus,
+            transcript_storage: absorb_storage, owner_task: owner,
+            prompt_reconstructible: prompt_reconstructible, profile_snapshot: profile_snapshot
+          )
+        end
+
+        def activate_and_release_subagent!(inst:, child_ctx:, owner:, activation_init:)
+          activate_instance!(inst, child_ctx: child_ctx, owner_token: owner,
+                                   init_supervisor: activation_init, defer_start: true)
+          raise "Subagent worker start gate could not be released." unless inst.release_start!
+        end
+
         def resolve_profile_snapshot(type_name:, role:, system_prompt:)
           reserved_name = RESERVED_ROLE_PROFILES[role.to_s.downcase.strip]
           if reserved_name

data/lib/rubik/platform/process.rb

@@ -162,17 +162,17 @@ module Rubik
           return pids.reject(&:zero?) unless pids.empty?
         end
 
-        out = begin
-          `pgrep -P #{pid} 2>/dev/null`
+        out, = begin
+          Open3.capture2("pgrep", "-P", pid.to_s, err: File::NULL)
         rescue StandardError
-          nil
+          [nil, nil]
         end
         return out.lines.map(&:to_i).reject(&:zero?) if out && !out.empty?
 
-        out = begin
-          `ps --ppid #{pid} -o pid= 2>/dev/null`
+        out, = begin
+          Open3.capture2("ps", "--ppid", pid.to_s, "-o", "pid=", err: File::NULL)
         rescue StandardError
-          nil
+          [nil, nil]
         end
         return out.lines.map(&:to_i).reject(&:zero?) if out && !out.empty?