rubik 0.3.3 → 0.3.5

data/lib/rubik/repl/commands/workspace.rb

@@ -34,101 +34,109 @@ module Rubik
             scope, clean_args = Base.parse_scope(args)
             sub = clean_args.first&.downcase || "list"
 
-            handle_add = lambda do |tokens_to_add|
-              entry_tokens = tokens_to_add.reject { |a| a == "--force" }
-              entry = entry_tokens.join(" ").strip
-              if entry.empty?
-                ctx.out.puts 'Usage: !allow-cmd add "<command prefix>" [--project|--global] [--force]'
-                return
-              end
-
-              tokens = entry.split(/\s+/)
-              # Fail closed (G3 triage, Priority-1 site): a classifier crash
-              # must not silently skip the broad-token RCE check — treat the
-              # token as broad and let the operator pass a narrow prefix.
-              broad = begin
-                base = Rubik::Security::Classifier.classify(tokens.first)
-                base.classification == :dangerous && tokens.size == 1
-              rescue StandardError => e
-                Rubik::Log.warn(:security, "classifier failed for '#{tokens.first}' (#{e.class}: #{e.message}); treating as broad")
-                true
-              end
-
-              # Fail-closed against unbounded execution: a broad, single-token
-              # dangerous entry (e.g. "node", "python", "bash") grants
-              # command execution for EVERY invocation of that binary, so
-              # `node` → `node -e 'malicious()'` RCE. Such broad tokens are
-              # blocked with or without --force — the operator should use a
-              # narrow prefix (e.g. "node .gitnexus/run.cjs").
-              if broad
-                ctx.out.puts "Blocked: '#{entry}' is a broad, single-token dangerous command. Even with --force it grants " \
-                             "unbounded command execution (e.g. `#{tokens.first} -e 'malicious(...)'` RCE). " \
-                             "Use a narrow prefix instead (e.g. \"#{tokens.first} <script>\")."
-                return
-              end
-
-              # The catastrophic destructive-pattern fallback always runs:
-              # a dangerous multi-token entry may never add `rm -rf /`-style
-              # chains to the allowlist, with or without --force.
-              catastrophic = false
-              begin
-                ctx.guard.verify_command_fallback_regex!(entry)
-              rescue Rubik::Security::BlockedWriteError => e
-                ctx.out.puts "Blocked: '#{entry}' matches a catastrophic destructive pattern and cannot be allowlisted: #{e.message}"
-                catastrophic = true
-              end
-              return if catastrophic
-
-              current = Array(ctx.config.fetch("security.command_allowlist", [])).dup
-              if current.include?(entry)
-                ctx.out.puts "[Rubik::AllowCmd] '#{entry}' is already allowlisted."
-                return
-              end
-              current << entry
-              res = ctx.config.set("security.command_allowlist", current, persist: scope)
-              ctx.guard&.log_audit("allowlist_add", command: entry, scope: scope)
-              next if Base.report_persist_failure(ctx, res, scope)
-
-              ctx.out.puts "[Rubik::AllowCmd] Added command prefix: #{entry} [#{Base.scope_label(scope)}]."
-            end
-
             case sub
             when "list", "status"
-              entries = Array(ctx.config.fetch("security.command_allowlist", []))
-              ctx.out.puts "=== Allowed Command Prefixes (operator allowlist) ==="
-              if entries.empty?
-                ctx.out.puts "  (No command prefixes allowlisted — unknown/dangerous commands stay blocked)"
-              else
-                entries.each_with_index { |e, idx| ctx.out.puts "  • [#{idx + 1}] #{e}" }
-              end
+              handle_allow_cmd_list(ctx)
             when "add"
-              handle_add.call(clean_args[1..])
+              handle_allow_cmd_add(ctx, clean_args[1..], scope)
             when "remove", "rm", "delete"
-              entry = clean_args[1..].join(" ").strip
-              if entry.empty?
-                ctx.out.puts "Usage: !allow-cmd remove \"<command prefix>\" [--project|--global]"
-                next
-              end
-
-              current = Array(ctx.config.fetch("security.command_allowlist", [])).dup
-              unless current.include?(entry)
-                ctx.out.puts "[Rubik::AllowCmd] '#{entry}' is not in the allowlist."
-                next
-              end
-              current.delete(entry)
-              res = ctx.config.set("security.command_allowlist", current, persist: scope)
-              ctx.guard&.log_audit("allowlist_remove", command: entry, scope: scope)
-              next if Base.report_persist_failure(ctx, res, scope)
-
-              ctx.out.puts "[Rubik::AllowCmd] Removed command prefix: #{entry} [#{Base.scope_label(scope)}]."
+              handle_allow_cmd_remove(ctx, clean_args, scope)
             when "help", "-h", "--help"
               ctx.out.puts USAGE_ALLOW_CMD
             else
-              handle_add.call(clean_args)
+              handle_allow_cmd_add(ctx, clean_args, scope)
             end
           end
         end
 
+        private_class_method def self.handle_allow_cmd_list(ctx)
+          entries = Array(ctx.config.fetch("security.command_allowlist", []))
+          ctx.out.puts "=== Allowed Command Prefixes (operator allowlist) ==="
+          if entries.empty?
+            ctx.out.puts "  (No command prefixes allowlisted — unknown/dangerous commands stay blocked)"
+          else
+            entries.each_with_index { |e, idx| ctx.out.puts "  • [#{idx + 1}] #{e}" }
+          end
+        end
+
+        private_class_method def self.handle_allow_cmd_add(ctx, tokens_to_add, scope)
+          entry_tokens = tokens_to_add.reject { |a| a == "--force" }
+          entry = entry_tokens.join(" ").strip
+          if entry.empty?
+            ctx.out.puts 'Usage: !allow-cmd add "<command prefix>" [--project|--global] [--force]'
+            return
+          end
+
+          tokens = entry.split(/\s+/)
+          # Fail closed (G3 triage, Priority-1 site): a classifier crash
+          # must not silently skip the broad-token RCE check — treat the
+          # token as broad and let the operator pass a narrow prefix.
+          broad = begin
+            base = Rubik::Security::Classifier.classify(tokens.first)
+            base.classification == :dangerous && tokens.size == 1
+          rescue StandardError => e
+            Rubik::Log.warn(:security, "classifier failed for '#{tokens.first}' (#{e.class}: #{e.message}); treating as broad")
+            true
+          end
+
+          # Fail-closed against unbounded execution: a broad, single-token
+          # dangerous entry (e.g. "node", "python", "bash") grants
+          # command execution for EVERY invocation of that binary, so
+          # `node` → `node -e 'malicious()'` RCE. Such broad tokens are
+          # blocked with or without --force — the operator should use a
+          # narrow prefix (e.g. "node .gitnexus/run.cjs").
+          if broad
+            ctx.out.puts "Blocked: '#{entry}' is a broad, single-token dangerous command. Even with --force it grants " \
+                         "unbounded command execution (e.g. `#{tokens.first} -e 'malicious(...)'` RCE). " \
+                         "Use a narrow prefix instead (e.g. \"#{tokens.first} <script>\")."
+            return
+          end
+
+          # The catastrophic destructive-pattern fallback always runs:
+          # a dangerous multi-token entry may never add `rm -rf /`-style
+          # chains to the allowlist, with or without --force.
+          catastrophic = false
+          begin
+            ctx.guard.verify_command_fallback_regex!(entry)
+          rescue Rubik::Security::BlockedWriteError => e
+            ctx.out.puts "Blocked: '#{entry}' matches a catastrophic destructive pattern and cannot be allowlisted: #{e.message}"
+            catastrophic = true
+          end
+          return if catastrophic
+
+          current = Array(ctx.config.fetch("security.command_allowlist", [])).dup
+          if current.include?(entry)
+            ctx.out.puts "[Rubik::AllowCmd] '#{entry}' is already allowlisted."
+            return
+          end
+          current << entry
+          res = ctx.config.set("security.command_allowlist", current, persist: scope)
+          ctx.guard&.log_audit("allowlist_add", command: entry, scope: scope)
+          return if Base.report_persist_failure(ctx, res, scope)
+
+          ctx.out.puts "[Rubik::AllowCmd] Added command prefix: #{entry} [#{Base.scope_label(scope)}]."
+        end
+
+        private_class_method def self.handle_allow_cmd_remove(ctx, clean_args, scope)
+          entry = clean_args[1..].join(" ").strip
+          if entry.empty?
+            ctx.out.puts "Usage: !allow-cmd remove \"<command prefix>\" [--project|--global]"
+            return
+          end
+
+          current = Array(ctx.config.fetch("security.command_allowlist", [])).dup
+          unless current.include?(entry)
+            ctx.out.puts "[Rubik::AllowCmd] '#{entry}' is not in the allowlist."
+            return
+          end
+          current.delete(entry)
+          res = ctx.config.set("security.command_allowlist", current, persist: scope)
+          ctx.guard&.log_audit("allowlist_remove", command: entry, scope: scope)
+          return if Base.report_persist_failure(ctx, res, scope)
+
+          ctx.out.puts "[Rubik::AllowCmd] Removed command prefix: #{entry} [#{Base.scope_label(scope)}]."
+        end
+
         private_class_method def self.register_workspace_command(shell)
           workspace_handler = lambda do |args, ctx|
             scope, clean_args = Base.parse_scope(args)
@@ -141,114 +149,130 @@ module Rubik
 
             case sub
             when "list", "status"
-              extra = ctx.buffer_manager&.additional_roots || []
-              rw_set = ctx.buffer_manager&.rw_roots || Set.new
-              allowed_ext = ctx.buffer_manager&.allowed_external_dirs || []
-              rw_allowed_set = ctx.buffer_manager&.rw_allowed_dirs || Set.new
-              glob_rw = ctx.buffer_manager&.allow_external_writes || false
-              auto_idx = ctx.config.fetch("workspace.auto_index_additional", true)
-
-              ctx.out.puts "=== Configured Workspace Roots ==="
-              ctx.out.puts "  • [PRIMARY] #{effective_root} (Read-Write)"
-              if extra.empty?
-                ctx.out.puts "  (No additional workspace roots configured)"
-              else
-                extra.each_with_index do |r, idx|
-                  mode_str = glob_rw || rw_set.include?(r) ? "Read-Write" : "Read-Only"
-                  ctx.out.puts "  • [EXTRA #{idx + 1}] #{r} (#{mode_str})"
-                end
-              end
+              handle_workspace_list(ctx, effective_root)
+            when "allow"
+              handle_workspace_allow(clean_args[1], ctx, is_ro, scope)
+            when "add"
+              handle_workspace_add(clean_args[1], ctx, is_rw, scope)
+            when "remove", "rm", "delete"
+              handle_workspace_remove(clean_args[1], ctx, scope, effective_root)
+            else
+              ctx.out.puts USAGE_WORKSPACE
+            end
+          end
 
-              ctx.out.puts "=== Allowed External Dirs (Zero-AST) ==="
-              if allowed_ext.empty?
-                ctx.out.puts "  (No allowed external directories configured)"
-              else
-                allowed_ext.each_with_index do |d, idx|
-                  mode_str = glob_rw || rw_allowed_set.include?(d) ? "Read-Write" : "Read-Only"
-                  ctx.out.puts "  • [ALLOWED #{idx + 1}] #{d} (#{mode_str})"
-                end
-              end
+          shell.register_command("workspace", description: "Manage multiple workspace roots (list|add <path> [--rw]|allow <path>|remove <path>)",
+                                              usage: USAGE_WORKSPACE, &workspace_handler)
+          shell.register_command("roots", description: "Alias for !workspace", usage: USAGE_WORKSPACE, &workspace_handler)
+        end
 
-              ctx.out.puts "External Writes Allowed Globally : #{glob_rw}"
-              ctx.out.puts "Auto-Index Additional Roots      : #{auto_idx}"
-            when "allow"
-              target_path = clean_args[1]
-              if target_path.nil? || target_path.empty?
-                ctx.out.puts "Usage: !workspace allow <path> [--rw|--ro] [--project|--global]"
-              else
-                begin
-                  ctx.guard.verify_root_safety!(target_path)
-                rescue Rubik::Security::BlockedWriteError => e
-                  ctx.out.puts "Security Error: #{e.message}"
-                  next
-                end
+        private_class_method def self.handle_workspace_list(ctx, effective_root)
+          extra = ctx.buffer_manager&.additional_roots || []
+          rw_set = ctx.buffer_manager&.rw_roots || Set.new
+          allowed_ext = ctx.buffer_manager&.allowed_external_dirs || []
+          rw_allowed_set = ctx.buffer_manager&.rw_allowed_dirs || Set.new
+          glob_rw = ctx.buffer_manager&.allow_external_writes || false
+          auto_idx = ctx.config.fetch("workspace.auto_index_additional", true)
+
+          ctx.out.puts "=== Configured Workspace Roots ==="
+          ctx.out.puts "  • [PRIMARY] #{effective_root} (Read-Write)"
+          if extra.empty?
+            ctx.out.puts "  (No additional workspace roots configured)"
+          else
+            extra.each_with_index do |r, idx|
+              mode_str = glob_rw || rw_set.include?(r) ? "Read-Write" : "Read-Only"
+              ctx.out.puts "  • [EXTRA #{idx + 1}] #{r} (#{mode_str})"
+            end
+          end
 
-                mode_rw = !is_ro
-                expanded = ctx.buffer_manager.add_allowed_dir(target_path, rw: mode_rw)
-                ctx.sandbox_runner&.add_allowed_dir(target_path)
+          ctx.out.puts "=== Allowed External Dirs (Zero-AST) ==="
+          if allowed_ext.empty?
+            ctx.out.puts "  (No allowed external directories configured)"
+          else
+            allowed_ext.each_with_index do |d, idx|
+              mode_str = glob_rw || rw_allowed_set.include?(d) ? "Read-Write" : "Read-Only"
+              ctx.out.puts "  • [ALLOWED #{idx + 1}] #{d} (#{mode_str})"
+            end
+          end
 
-                current_dirs = Array(ctx.config.fetch("workspace.allowed_external_dirs", [])).dup
-                current_dirs << target_path unless current_dirs.include?(target_path)
-                res = ctx.config.set("workspace.allowed_external_dirs", current_dirs, persist: scope)
-                next if Base.report_persist_failure(ctx, res, scope)
+          ctx.out.puts "External Writes Allowed Globally : #{glob_rw}"
+          ctx.out.puts "Auto-Index Additional Roots      : #{auto_idx}"
+        end
 
-                mode_str = mode_rw ? "Read-Write" : "Read-Only"
-                ctx.out.puts "[Rubik::Allow] Added allowed external directory: #{expanded} (Mode: #{mode_str}) [#{Base.scope_label(scope)}]."
-              end
-            when "add"
-              target_path = clean_args[1]
-              if target_path.nil? || target_path.empty?
-                ctx.out.puts "Usage: !workspace add <path> [--rw] [--project|--global]"
-              else
-                begin
-                  ctx.guard.verify_root_safety!(target_path)
-                rescue Rubik::Security::BlockedWriteError => e
-                  ctx.out.puts "Security Error: #{e.message}"
-                  next
-                end
+        private_class_method def self.handle_workspace_allow(target_path, ctx, is_ro, scope)
+          if target_path.nil? || target_path.empty?
+            ctx.out.puts "Usage: !workspace allow <path> [--rw|--ro] [--project|--global]"
+            return
+          end
 
-                expanded = ctx.buffer_manager.add_root(target_path, rw: is_rw)
+          begin
+            ctx.guard.verify_root_safety!(target_path)
+          rescue Rubik::Security::BlockedWriteError => e
+            ctx.out.puts "Security Error: #{e.message}"
+            return
+          end
 
-                # Sync context index & AST coeffects
-                auto_idx = ctx.config.fetch("workspace.auto_index_additional", true)
-                ctx.sync_workspace_index! if auto_idx
+          mode_rw = !is_ro
+          expanded = ctx.buffer_manager.add_allowed_dir(target_path, rw: mode_rw)
+          ctx.sandbox_runner&.add_allowed_dir(target_path)
 
-                # Persist to config
-                current_roots = Array(ctx.config.fetch("workspace.additional_roots", [])).dup
-                current_roots << target_path unless current_roots.include?(target_path)
-                res = ctx.config.set("workspace.additional_roots", current_roots, persist: scope)
-                next if Base.report_persist_failure(ctx, res, scope)
+          current_dirs = Array(ctx.config.fetch("workspace.allowed_external_dirs", [])).dup
+          current_dirs << target_path unless current_dirs.include?(target_path)
+          res = ctx.config.set("workspace.allowed_external_dirs", current_dirs, persist: scope)
+          return if Base.report_persist_failure(ctx, res, scope)
 
-                mode_str = is_rw ? "Read-Write" : "Read-Only"
-                ctx.out.puts "[Rubik::Workspace] Added additional root: #{expanded} (Mode: #{mode_str}) [#{Base.scope_label(scope)}]."
-              end
-            when "remove", "rm", "delete"
-              target_path = clean_args[1]
-              if target_path.nil? || target_path.empty?
-                ctx.out.puts "Usage: !workspace remove <path> [--project|--global]"
-              else
-                expanded = ctx.buffer_manager.remove_root(target_path)
+          mode_str = mode_rw ? "Read-Write" : "Read-Only"
+          ctx.out.puts "[Rubik::Allow] Added allowed external directory: #{expanded} (Mode: #{mode_str}) [#{Base.scope_label(scope)}]."
+        end
 
-                # Sync context index & AST coeffects
-                auto_idx = ctx.config.fetch("workspace.auto_index_additional", true)
-                ctx.sync_workspace_index! if auto_idx
+        private_class_method def self.handle_workspace_add(target_path, ctx, is_rw, scope)
+          if target_path.nil? || target_path.empty?
+            ctx.out.puts "Usage: !workspace add <path> [--rw] [--project|--global]"
+            return
+          end
 
-                # Persist to config
-                current_roots = Array(ctx.config.fetch("workspace.additional_roots", [])).dup
-                current_roots.reject! { |r| File.expand_path(r, effective_root) == expanded || r == target_path }
-                res = ctx.config.set("workspace.additional_roots", current_roots, persist: scope)
-                next if Base.report_persist_failure(ctx, res, scope)
+          begin
+            ctx.guard.verify_root_safety!(target_path)
+          rescue Rubik::Security::BlockedWriteError => e
+            ctx.out.puts "Security Error: #{e.message}"
+            return
+          end
 
-                ctx.out.puts "[Rubik::Workspace] Removed additional root: #{expanded} [#{Base.scope_label(scope)}]."
-              end
-            else
-              ctx.out.puts USAGE_WORKSPACE
-            end
+          expanded = ctx.buffer_manager.add_root(target_path, rw: is_rw)
+
+          # Sync context index & AST coeffects
+          auto_idx = ctx.config.fetch("workspace.auto_index_additional", true)
+          ctx.sync_workspace_index! if auto_idx
+
+          # Persist to config
+          current_roots = Array(ctx.config.fetch("workspace.additional_roots", [])).dup
+          current_roots << target_path unless current_roots.include?(target_path)
+          res = ctx.config.set("workspace.additional_roots", current_roots, persist: scope)
+          return if Base.report_persist_failure(ctx, res, scope)
+
+          mode_str = is_rw ? "Read-Write" : "Read-Only"
+          ctx.out.puts "[Rubik::Workspace] Added additional root: #{expanded} (Mode: #{mode_str}) [#{Base.scope_label(scope)}]."
+        end
+
+        private_class_method def self.handle_workspace_remove(target_path, ctx, scope, effective_root)
+          if target_path.nil? || target_path.empty?
+            ctx.out.puts "Usage: !workspace remove <path> [--project|--global]"
+            return
           end
 
-          shell.register_command("workspace", description: "Manage multiple workspace roots (list|add <path> [--rw]|allow <path>|remove <path>)",
-                                              usage: USAGE_WORKSPACE, &workspace_handler)
-          shell.register_command("roots", description: "Alias for !workspace", usage: USAGE_WORKSPACE, &workspace_handler)
+          expanded = ctx.buffer_manager.remove_root(target_path)
+
+          # Sync context index & AST coeffects
+          auto_idx = ctx.config.fetch("workspace.auto_index_additional", true)
+          ctx.sync_workspace_index! if auto_idx
+
+          # Persist to config
+          current_roots = Array(ctx.config.fetch("workspace.additional_roots", [])).dup
+          current_roots.reject! { |r| File.expand_path(r, effective_root) == expanded || r == target_path }
+          res = ctx.config.set("workspace.additional_roots", current_roots, persist: scope)
+          return if Base.report_persist_failure(ctx, res, scope)
+
+          ctx.out.puts "[Rubik::Workspace] Removed additional root: #{expanded} [#{Base.scope_label(scope)}]."
         end
 
         private_class_method def self.register_allow_command(shell)
@@ -263,80 +287,16 @@ module Rubik
 
             case sub
             when "list", "status"
-              allowed = ctx.buffer_manager&.allowed_external_dirs || []
-              rw_set = ctx.buffer_manager&.rw_allowed_dirs || Set.new
-              glob_rw = ctx.buffer_manager&.allow_external_writes || false
-
-              ctx.out.puts "=== Allowed External Directories (Zero-AST / Zero-Scanner) ==="
-              if allowed.empty?
-                ctx.out.puts "  (No allowed external directories configured)"
-              else
-                allowed.each_with_index do |d, idx|
-                  mode_str = glob_rw || rw_set.include?(d) ? "Read-Write" : "Read-Only"
-                  ctx.out.puts "  • [ALLOWED #{idx + 1}] #{d} (#{mode_str})"
-                end
-              end
+              handle_allow_list(ctx)
             when "remove", "rm", "delete"
-              target_path = clean_args[1]
-              if target_path.nil? || target_path.empty?
-                ctx.out.puts "Usage: !allow remove <path> [--project|--global]"
-              else
-                expanded = ctx.buffer_manager&.remove_allowed_dir(target_path)
-                ctx.sandbox_runner&.remove_allowed_dir(target_path)
-
-                # Persist to config
-                current_dirs = Array(ctx.config.fetch("workspace.allowed_external_dirs", [])).dup
-                current_dirs.reject! { |d| File.expand_path(d, effective_root) == expanded || d == target_path }
-                res = ctx.config.set("workspace.allowed_external_dirs", current_dirs, persist: scope)
-                next if Base.report_persist_failure(ctx, res, scope)
-
-                ctx.out.puts "[Rubik::Allow] Removed allowed external directory: #{expanded} [#{Base.scope_label(scope)}]."
-              end
+              handle_allow_remove(clean_args[1], ctx, scope, effective_root)
             when "add"
-              target_path = clean_args[1]
-              if target_path.nil? || target_path.empty?
-                ctx.out.puts "Usage: !allow add <path> [--rw|--ro] [--project|--global]"
-              else
-                begin
-                  ctx.guard.verify_root_safety!(target_path)
-                rescue Rubik::Security::BlockedWriteError => e
-                  ctx.out.puts "Security Error: #{e.message}"
-                  next
-                end
-
-                expanded = ctx.buffer_manager.add_allowed_dir(target_path, rw: mode_rw)
-                ctx.sandbox_runner&.add_allowed_dir(target_path)
-
-                # Persist to config (Zero-AST / Zero-Scanner: No IndexService or AST warm)
-                current_dirs = Array(ctx.config.fetch("workspace.allowed_external_dirs", [])).dup
-                current_dirs << target_path unless current_dirs.include?(target_path)
-                res = ctx.config.set("workspace.allowed_external_dirs", current_dirs, persist: scope)
-                next if Base.report_persist_failure(ctx, res, scope)
-
-                mode_str = mode_rw ? "Read-Write" : "Read-Only"
-                ctx.out.puts "[Rubik::Allow] Added allowed external directory: #{expanded} (Mode: #{mode_str}) [#{Base.scope_label(scope)}]."
-              end
+              handle_allow_add(clean_args[1], ctx, scope, mode_rw)
             else
               # First argument is target path directly
               target_path = clean_args.first
               if target_path && !target_path.empty?
-                begin
-                  ctx.guard.verify_root_safety!(target_path)
-                rescue Rubik::Security::BlockedWriteError => e
-                  ctx.out.puts "Security Error: #{e.message}"
-                  next
-                end
-
-                expanded = ctx.buffer_manager.add_allowed_dir(target_path, rw: mode_rw)
-                ctx.sandbox_runner&.add_allowed_dir(target_path)
-
-                current_dirs = Array(ctx.config.fetch("workspace.allowed_external_dirs", [])).dup
-                current_dirs << target_path unless current_dirs.include?(target_path)
-                res = ctx.config.set("workspace.allowed_external_dirs", current_dirs, persist: scope)
-                next if Base.report_persist_failure(ctx, res, scope)
-
-                mode_str = mode_rw ? "Read-Write" : "Read-Only"
-                ctx.out.puts "[Rubik::Allow] Added allowed external directory: #{expanded} (Mode: #{mode_str}) [#{Base.scope_label(scope)}]."
+                handle_allow_add(target_path, ctx, scope, mode_rw)
               else
                 cmd_name = invoked_as == :allow ? "allow" : "allow-dir"
                 ctx.out.puts format(USAGE_ALLOW, cmd: cmd_name)
@@ -359,6 +319,66 @@ module Rubik
                                           usage: format(USAGE_ALLOW, cmd: "allow"), &deprecated_allow_wrapper)
         end
 
+        private_class_method def self.handle_allow_list(ctx)
+          allowed = ctx.buffer_manager&.allowed_external_dirs || []
+          rw_set = ctx.buffer_manager&.rw_allowed_dirs || Set.new
+          glob_rw = ctx.buffer_manager&.allow_external_writes || false
+
+          ctx.out.puts "=== Allowed External Directories (Zero-AST / Zero-Scanner) ==="
+          if allowed.empty?
+            ctx.out.puts "  (No allowed external directories configured)"
+          else
+            allowed.each_with_index do |d, idx|
+              mode_str = glob_rw || rw_set.include?(d) ? "Read-Write" : "Read-Only"
+              ctx.out.puts "  • [ALLOWED #{idx + 1}] #{d} (#{mode_str})"
+            end
+          end
+        end
+
+        private_class_method def self.handle_allow_remove(target_path, ctx, scope, effective_root)
+          if target_path.nil? || target_path.empty?
+            ctx.out.puts "Usage: !allow remove <path> [--project|--global]"
+            return
+          end
+
+          expanded = ctx.buffer_manager&.remove_allowed_dir(target_path)
+          ctx.sandbox_runner&.remove_allowed_dir(target_path)
+
+          # Persist to config
+          current_dirs = Array(ctx.config.fetch("workspace.allowed_external_dirs", [])).dup
+          current_dirs.reject! { |d| File.expand_path(d, effective_root) == expanded || d == target_path }
+          res = ctx.config.set("workspace.allowed_external_dirs", current_dirs, persist: scope)
+          return if Base.report_persist_failure(ctx, res, scope)
+
+          ctx.out.puts "[Rubik::Allow] Removed allowed external directory: #{expanded} [#{Base.scope_label(scope)}]."
+        end
+
+        private_class_method def self.handle_allow_add(target_path, ctx, scope, mode_rw)
+          if target_path.nil? || target_path.empty?
+            ctx.out.puts "Usage: !allow add <path> [--rw|--ro] [--project|--global]"
+            return
+          end
+
+          begin
+            ctx.guard.verify_root_safety!(target_path)
+          rescue Rubik::Security::BlockedWriteError => e
+            ctx.out.puts "Security Error: #{e.message}"
+            return
+          end
+
+          expanded = ctx.buffer_manager.add_allowed_dir(target_path, rw: mode_rw)
+          ctx.sandbox_runner&.add_allowed_dir(target_path)
+
+          # Persist to config (Zero-AST / Zero-Scanner: No IndexService or AST warm)
+          current_dirs = Array(ctx.config.fetch("workspace.allowed_external_dirs", [])).dup
+          current_dirs << target_path unless current_dirs.include?(target_path)
+          res = ctx.config.set("workspace.allowed_external_dirs", current_dirs, persist: scope)
+          return if Base.report_persist_failure(ctx, res, scope)
+
+          mode_str = mode_rw ? "Read-Write" : "Read-Only"
+          ctx.out.puts "[Rubik::Allow] Added allowed external directory: #{expanded} (Mode: #{mode_str}) [#{Base.scope_label(scope)}]."
+        end
+
         private_class_method def self.register_config_command(shell)
           shell.register_command("config", description: "Get, set, or view runtime configuration (set|get|list|path)",
                                            usage: USAGE_CONFIG, audience: :both) do |args, ctx|

data/lib/rubik/repl/shell.rb

@@ -92,7 +92,16 @@ module Rubik
         files.each do |rel_file|
           @context_index.update_file(rel_file)
           full_path = File.join(root_d, rel_file)
-          File.exist?(full_path) ? @ast_graph.index_file(full_path) : @ast_graph.remove_file(full_path)
+          if File.exist?(full_path)
+            @ast_graph.index_file(full_path)
+            if @lsp_manager&.enabled?
+              content = Rubik::Platform.read_text(full_path)
+              @lsp_manager.sync_buffer_file(rel_file, content)
+              @lsp_manager.did_save_file(rel_file, content)
+            end
+          else
+            @ast_graph.remove_file(full_path)
+          end
         end
         @ast_graph.save_to_cache(@cache_store) if @cache_store
       end

data/lib/rubik/runtime/discovery.rb

@@ -2,6 +2,7 @@
 
 require "shellwords"
 require_relative "../platform"
+require_relative "../lsp/server_command"
 
 module Rubik
   module Runtime
@@ -179,22 +180,27 @@ module Rubik
         end
 
         def binary_available?(cmd, root_dir: nil)
-          return false if cmd.nil? || cmd.to_s.strip.empty?
+          argv = Rubik::LSP::ServerCommand.argv(cmd)
+          return false if argv.empty?
 
-          bin = cmd.to_s.strip.split.first
-          if root_dir && bin && (bin.include?("/") || (Rubik::Platform.windows? && bin.include?("\\")))
-            full_path = File.expand_path(bin, root_dir)
+          bin = argv.first
+          if bin.include?("/") || (Rubik::Platform.windows? && bin.include?("\\"))
+            full_path = File.expand_path(bin, root_dir || Dir.pwd)
             return true if Rubik::Platform.executable_file?(full_path)
+
+            return false
           end
 
-          !Rubik::Platform.which(cmd).nil?
+          !Rubik::Platform.which(bin).nil?
+        rescue ArgumentError
+          false
         end
 
         def probe_lsp(lang, dir = nil, root_dir: nil, custom_cmd: nil)
           effective_root = root_dir || dir || Dir.pwd
           lang_key = lang.to_s.downcase
           candidates = []
-          candidates << custom_cmd.to_s.strip if custom_cmd && !custom_cmd.to_s.strip.empty?
+          candidates << custom_cmd if custom_cmd && !Rubik::LSP::ServerCommand.argv(custom_cmd).empty?
           candidates.concat(lsp_candidates(lang_key))
           candidates.uniq!