rubik 0.1.4 → 0.1.6

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "notices"
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      # Wait semantics (issue #126): waiting already knew when it returned; now
+      # it reports WHY — settled, deadline (targets still active), an actionable
+      # pause, a dependency queue, or unknown ids. The supervisor keeps
+      # wait_for (rows only) for its existing callers; the tool surface reads
+      # the reason so the model gets a truthful next action instead of guessing
+      # whether a timeout meant failure.
+      module WaitSupervisor
+        WaitOutcome = Struct.new(:reason, :rows, :paused, :active, keyword_init: true) do
+          def settled? = reason == :settled
+        end
+
+        def wait_for(ids = nil, timeout: Notices::DEFAULT_WAIT_TIMEOUT, wait_for_budget: true)
+          wait(ids, timeout: timeout, wait_for_budget: wait_for_budget).rows
+        end
+
+        def wait(ids = nil, timeout: Notices::DEFAULT_WAIT_TIMEOUT, wait_for_budget: true)
+          target_ids = Array(ids).compact.map(&:to_s)
+          deadline = Time.now + [timeout.to_i, 1].max
+
+          loop do
+            active_targets = @monitor.synchronize do
+              candidates = target_ids.empty? ? @instances.values : target_ids.filter_map { |id| @instances[id] }
+              candidates.select do |inst|
+                inst.active? && !inst.error_paused? && !inst.awaiting_human? && (!wait_for_budget || !inst.awaiting_budget?)
+              end
+            end
+
+            # Kuyruğa takılı hedefler wait'i canlı tutar (zincir bitene dek).
+            break if (active_targets.empty? && !deferred_pending?(target_ids)) || Time.now >= deadline
+
+            sleep 0.1
+          end
+
+          @monitor.synchronize do
+            candidates = target_ids.empty? ? @instances.values : target_ids.filter_map { |id| @instances[id] || queued_spec(id) }
+            paused = candidates.select { |c| parked_candidate?(c) }
+            active = candidates.select { |c| c.respond_to?(:active?) && c.active? }
+            WaitOutcome.new(reason: wait_reason(target_ids, candidates, active, deadline),
+                            rows: candidates.map(&:to_h),
+                            paused: paused.map(&:id),
+                            active: active.map(&:id))
+          end
+        end
+
+        private
+
+        # The returned-fact classification, derived from what was observed —
+        # never from a guess about the model's intent.
+        def wait_reason(target_ids, candidates, active, deadline)
+          return :unknown if target_ids.any? && candidates.empty?
+          return :deadline if Time.now >= deadline && active.any?
+          return :paused if candidates.any? { |c| parked_candidate?(c) }
+          return :queued if candidates.any? { |c| c.respond_to?(:queued?) && c.queued? }
+
+          :settled
+        end
+
+        def parked_candidate?(candidate)
+          (candidate.respond_to?(:error_paused?) && candidate.error_paused?) ||
+            (candidate.respond_to?(:awaiting_human?) && candidate.awaiting_human?) ||
+            (candidate.respond_to?(:awaiting_budget?) && candidate.awaiting_budget?)
+        end
+      end
+    end
+  end
+end

data/lib/rubik/orchestrator/task_cancellation.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Rubik
+  module Orchestrator
+    # Foreground task cancellation token (issue #125).
+    #
+    # A foreground turn (or any explicit task scope) owns the subagents it
+    # spawns: the token is provided into the runtime context for the turn's
+    # duration and inherited — transitively — by the child contexts of the
+    # spawned subagents, so nested spawns remain owned by the same task. The
+    # interrupt handler cancels the token and the supervisor stops every
+    # execution still carrying it; work that was explicitly detached (no
+    # owner) or spawned under a different token is untouched by construction.
+    #
+    # The token is a leaf: no dependencies, no callbacks, no IO — cancellation
+    # REQUEST state only. The supervisor owns the stop choreography and the
+    # outcome report (cancellation-requested → complete / remaining), keeping
+    # this object honest about what it knows.
+    class TaskCancellation
+      attr_reader :id, :reason, :cancelled_at
+
+      # The owner of explicitly detached work: a token that can never be
+      # cancelled, provided into a detached subagent's child context so its
+      # own descendants inherit the detachment instead of the turn's token.
+      def self.detached
+        new(id: "task-detached-#{Process.pid}-#{rand(1000..9999)}", detached: true)
+      end
+
+      def initialize(id: nil, detached: false)
+        @id = id || "task-#{Process.pid}-#{Time.now.to_i}-#{rand(1000..9999)}"
+        @detached = detached
+        @monitor = Monitor.new
+        @cancelled = false
+        @reason = nil
+        @cancelled_at = nil
+      end
+
+      def cancelled? = @monitor.synchronize { @cancelled }
+
+      def detached? = @detached
+
+      # Idempotent: the first cancel wins (its reason/timestamp is the record),
+      # later calls report false and change nothing.
+      def cancel!(reason = "foreground task cancelled (^C)")
+        @monitor.synchronize do
+          return false if @detached || @cancelled
+
+          @cancelled = true
+          @reason = reason.to_s
+          @cancelled_at = Time.now
+          true
+        end
+      end
+    end
+  end
+end

data/lib/rubik/orchestrator/tool_history.rb

@@ -22,15 +22,20 @@ module Rubik
     # - content — an opaque String per channel (main path: Result#to_xml;
     #   subagent: truncated plain output). The dictionary unifies the row
     #   SHAPE, not the content encoding.
+    # - exit_code / metadata (issue #127) — the structured command outcome:
+    #   machine-readable status without parsing display text. Also read by no
+    #   wire-side consumer (same observability-only contract as status), so
+    #   every channel writing nil/{} keeps the shape stable.
     module ToolHistory
-      ROW_KEYS = [:role, :tool_call_id, :tool_name, :status, :duration_ms, :content].freeze
+      ROW_KEYS = [:role, :tool_call_id, :tool_name, :status, :duration_ms, :content, :exit_code, :metadata].freeze
 
       module_function
 
       # Appends exactly one canonical row to +history+ and returns it.
-      def write(history, tool_call_id:, tool_name:, status:, duration_ms:, content:)
+      def write(history, tool_call_id:, tool_name:, status:, duration_ms:, content:, exit_code: nil, metadata: nil)
         row = { role: "tool", tool_call_id: tool_call_id, tool_name: tool_name,
-                status: status, duration_ms: duration_ms, content: content }
+                status: status, duration_ms: duration_ms, content: content,
+                exit_code: exit_code, metadata: metadata || {} }
         history << row
         row
       end

data/lib/rubik/prompt/context_builder.rb

@@ -334,7 +334,7 @@ module Rubik
         tool_section = if tool_schemas.nil? || tool_schemas.empty?
                          ""
                        elsif native_tools
-                         names = tool_schemas.map { |t| t[:name] || t["name"] }.compact.join(", ")
+                         names = tool_schemas.filter_map { |t| t[:name] || t["name"] }.join(", ")
                          Doctrine.native_tools_note(names)
                        else
                          Doctrine.json_tools_note(tool_schemas)

data/lib/rubik/prompt/doctrine.rb

@@ -34,9 +34,9 @@ module Rubik
             4. REPL Bang Commands: `exec_repl_command` runs only the session-safe commands listed in <agent_commands> — runtime configuration, context and step-budget self-management, buffer review and rollback, runtime introspection, and code validation. If that section is absent, do not invoke REPL commands. File, code, test, and shell operations never travel through REPL commands — under the maestro doctrine (rules 2-3) they are delegated to subagents, and the direct tools (`read_file`, `write_file`, `replace_file_content`, `run_tests`, `run_command`) are your coder subagents' mechanics. Buffer-review commands (`!diff`, `!undo`, `!rollback`) operate on the in-memory staging buffer (unapplied edits) — they are a preview layer, not file ground truth: verify file content with `read_file`, and read git history from your coder subagent's `run_command` report.
             5. Autonomous Tool Synthesis: #{Rubik::Prompt::ToolTeachings.teaching_for('synthesize_tool')}
             6. Output Budget & Conciseness: Respect your output token budget (`<output_budget>`). Produce direct, high-signal responses and avoid unnecessary pleasantries, verbose conversational preambles, or duplicated context blocks that waste generation quota.
-            7. Subagent Delegation & Parallelism (Maestro): As the maestro you orchestrate — ALL execution work (exploration, code changes, verification) is delegated via `invoke_subagent`, in every mode. Match task to archetype: use 'research' for read-only codebase exploration; MUST use 'coder' for code modifications, refactoring, and test execution ('research' has no write or test tools); reach for 'self' (a full capability clone, minus subagent spawning) for work that fits neither archetype — runtime introspection/repair, self-evolution work, hybrid tasks. Subagents execute asynchronously in disposable sub-contexts in the background. For non-trivial modifications, allocate sufficient step budget (e.g. `max_steps: 100-140`) to prevent avoidable mid-flight pauses. When chaining stages with `depends_on`, direct the successor to read the predecessor's transcript via `read_file('rubik://storage/<predecessor-id>/transcript')`. Consume subagents' structured reports (Outcome, Changes/Locations, Verification/Findings, Assumptions) directly. After dispatching subagents, do NOT block with 'wait' unless you strictly depend on their output in the current turn — conclude your turn and liberate the prompt so the user can interact concurrently. Completion, budget-pause, error, and message notifications arrive reactively: during your turn via your notification inbox; while you are idle, the runtime automatically wakes you with a dedicated notification-evaluation turn — evaluate the pending notifications, act (extend budget, steer with send_message, retrieve results, wrap up, or report to the user), and conclude your turn again. Subagents can ask YOU questions mid-flight via `ask_question` — a question notification means that subagent is BLOCKED until you reply: answer it promptly with `send_message(recipient: '<id>', message: '<your answer>')` (it times out otherwise). Call `#{Rubik::Orchestrator::Subagent::Notices.wait_hint_template}` only when synchronous waiting is strictly required. Never poll 'status' repeatedly in a loop.
+            7. Subagent Delegation & Parallelism (Maestro): As the maestro you orchestrate — ALL execution work (exploration, code changes, verification) is delegated via `invoke_subagent`, in every mode. Match task to archetype: use 'research' for read-only codebase exploration; MUST use 'coder' for code modifications, refactoring, and test execution ('research' has no write or test tools); reach for 'self' (a full capability clone, minus subagent spawning) for work that fits neither archetype — runtime introspection/repair, self-evolution work, hybrid tasks. Subagents execute asynchronously in disposable sub-contexts in the background. For non-trivial modifications, allocate sufficient step budget (e.g. `max_steps: 100-140`) to prevent avoidable mid-flight pauses. When chaining stages with `depends_on`, hand the successor the predecessor's canonical transcript reference (`read_file('rubik://subagent/<storage-id>/transcript')`, reported by status/completion notices) — never a handwritten storage path; if the successor launches before the storage id is known, paste the predecessor's findings into its brief. Consume subagents' structured reports (Outcome, Changes/Locations, Verification/Findings, Assumptions) directly. After dispatching subagents, do NOT block with 'wait' unless you strictly depend on their output in the current turn — conclude your turn and liberate the prompt so the user can interact concurrently. Completion, budget-pause, error, and message notifications arrive reactively: during your turn via your notification inbox; while you are idle, the runtime automatically wakes you with a dedicated notification-evaluation turn — evaluate the pending notifications, act (extend budget, steer with send_message, retrieve results, wrap up, or report to the user), and conclude your turn again. Subagents can ask YOU questions mid-flight via `ask_question` — a question notification means that subagent is BLOCKED until you reply: answer it promptly with `send_message(recipient: '<id>', message: '<your answer>')` (it times out otherwise). Call `#{Rubik::Orchestrator::Subagent::Notices.wait_hint_template}` only when synchronous waiting is strictly required. Never poll 'status' repeatedly in a loop.
             8. Runtime Introspection, Self-Healing & Human Feedback: If internal errors or service degradation occur, inspect runtime state with `inspect_runtime` and repair failed services via `repair_runtime_service`. When critical requirements are underspecified or high-impact architectural choices require user confirmation, use `ask_question` with structured multiple-choice options.
-            9. Central Storage & Clean Worktree: #{Rubik::Prompt::ToolTeachings.teaching_for('storage')} #{Rubik::Prompt::ToolTeachings.teaching_for('vakanuvis')} #{Rubik::Prompt::ToolTeachings.teaching_for('show_file')} Subagent transcripts are indexed automatically as `transcript` entities (alias `subagent-<storage-id>`). #{Rubik::Prompt::ToolTeachings.teaching_for('prune_context')}
+            9. Central Storage & Clean Worktree: #{Rubik::Prompt::ToolTeachings.teaching_for('storage')} #{Rubik::Prompt::ToolTeachings.teaching_for('vakanuvis')} #{Rubik::Prompt::ToolTeachings.teaching_for('show_file')} Subagent transcripts are indexed automatically as `transcript` entities (alias `subagent-<storage-id>`) and are readable live or persisted via the canonical `rubik://subagent/<storage-id>/transcript` reference — indexed entities and live history have different availability, so address the exact execution by its unique storage id (from status/completion notices), never by a display id or a disk path. #{Rubik::Prompt::ToolTeachings.teaching_for('prune_context')}
           </operational_rules>
         XML
       end
@@ -117,7 +117,9 @@ module Rubik
           "and `wait` accepts queued ids (blocks until the whole chain settles). A failed/killed predecessor " \
           "CANCELS its dependents — re-dispatch with the new information; a budget- or error-paused predecessor " \
           "keeps them queued — extend or resume it instead. When chaining dependent stages, direct the successor " \
-          "to read predecessor findings via `read_file('rubik://storage/<predecessor-id>/transcript')`.",
+          "to read predecessor findings via the canonical transcript reference " \
+          "(`read_file('rubik://subagent/<storage-id>/transcript')`, from status/completion notices) — never a " \
+          "handwritten storage path; the findings can also be pasted into the brief.",
           "Chronicler briefs: when dispatching a subagent, paste the relevant chronicled knowledge into the task " \
           "brief — the recall digest or a rubik://storage/... link — so the subagent pulls the depth itself. " \
           "Subagents never see the `vakanuvis` tool; you are the only librarian.",

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

@@ -94,6 +94,8 @@ module Rubik
           ctx.out.puts "  Uptime:      #{inst.uptime.round(2)}s"
           ctx.out.puts "  Workspace:   #{inst.workspace}"
           ctx.out.puts "  Transcript:  #{inst.transcript_uri}"
+          # Canonical read reference (issue #123): the path above is diagnostic.
+          ctx.out.puts "  Read Ref:    #{inst.transcript_ref}" if inst.respond_to?(:transcript_ref)
           ctx.out.puts "  Last Error:  #{inst.last_error}" if inst.last_error
           ctx.out.puts "  Result:      #{inst.result.to_s.slice(0, 150)}..." if inst.result
         end

data/lib/rubik/repl/input_execution.rb

@@ -148,6 +148,13 @@ module Rubik
         # an unbound read would mask the in-flight exception with a
         # NameError, breaking the "cleanup must never mask" contract.
         interrupted = false
+        # Task ownership (issue #125): this turn owns the subagents it spawns.
+        # The token is published for the turn's duration; ^C cancels it and the
+        # supervisor stops exactly the owned descendants (detached work and
+        # older turns' executions carry different tokens and survive).
+        task = Rubik::Orchestrator::TaskCancellation.new
+        @active_task = task
+        @runtime_manager&.provide(Rubik::Coeffects::TASK_CANCELLATION, task)
         # Plan 109 staleness rule (see execute_command): a real turn's
         # context already includes the idle-injected notices. The notice
         # turn itself drains first, so this clear is a no-op for it.
@@ -271,6 +278,10 @@ module Rubik
         # at route time), so draining loses nothing the model needed.
         clear_pending_wake_notices! if respond_to?(:clear_pending_wake_notices!)
         Rubik::REPL::InterruptHandler.restore_console_after_interrupt
+        # Propagate the cancellation to owned work (issue #125) and report the
+        # fact: with nothing owned running this reads as an interrupted wait,
+        # with owned descendants it reads as a cancelled task tree.
+        task_cancellation_lines(cancel_foreground_task!(task)).each { |line| @output.puts line }
         # Dedicated event type: restore_session must NOT hydrate this as a
         # dialogue turn (the user_turn recorded at method entry already
         # carries the question; a repl_command-style pair would duplicate it).
@@ -294,6 +305,7 @@ module Rubik
         record_failed_turn!(text, "failed", "#{e.class}: #{message}", orchestrator)
       ensure
         @active_loop = nil
+        @active_task = nil
         # Flush a half-streamed markdown tail so an interrupt never eats the last
         # line. Cleanup must never mask the in-flight exception (Interrupt, LLM
         # error): each step reports its own failure to stderr instead of raising.
@@ -320,6 +332,36 @@ module Rubik
         reap_dead_kernel_units! if respond_to?(:reap_dead_kernel_units!)
       end
 
+      # Foreground task cancellation (issue #125): cancel the turn's token and
+      # stop its owned descendants within the configured grace period. Returns
+      # the supervisor's fact report (nil when no supervisor is wired).
+      def cancel_foreground_task!(task)
+        supervisor = Rubik::Coeffects.get(@runtime_manager&.context, Rubik::Coeffects::SUBAGENT_SUPERVISOR)
+        return nil unless task && supervisor.respond_to?(:cancel_owned)
+
+        supervisor.cancel_owned(task, timeout: @config.fetch("subagents.cancel_timeout", 2.0))
+      rescue StandardError => e
+        warn "[rubik] task cancellation failed: #{e.class}: #{e.message}"
+        nil
+      end
+
+      # The UI's two truths (issue #125): an interrupt with nothing owned is an
+      # interrupted WAIT; one with owned work is a cancelled TASK TREE — and
+      # remaining work is named, so an incomplete cleanup is never silent.
+      def task_cancellation_lines(outcome)
+        return ["⏸️  [Rubik] Bekleme kesildi (^C) — iptal edilecek bağlı alt ajan yok."] unless outcome&.any?
+
+        line = "🛑 [Rubik] Görev ağacı iptal edildi (^C): #{outcome.stopped.size} bağlı alt ajan durduruldu"
+        line << ", #{outcome.queued_cancelled.size} kuyruk işi iptal edildi" unless outcome.queued_cancelled.empty?
+        if outcome.complete?
+          line << "; temizlik tamamlandı."
+        else
+          remaining = outcome.remaining.map { |r| "#{r[:id]}:#{r[:state]}" }.join(", ")
+          line << "; temizlik TAMAMLANMADI — kalan: #{remaining}."
+        end
+        [line]
+      end
+
       # Shared spinner teardown. Cleanup must never mask the in-flight
       # exception (AGENTS.md §5): a spinner whose tick thread died holding
       # the mutex raises ThreadError from synchronize — report it to stderr

data/lib/rubik/repl/input_loop.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "prompt_grace"
+
 module Rubik
   module REPL
     # Öneri 3 (Kademe 1): Shell'den ayrılan girdi döngüsü sorumluluğu.
@@ -18,6 +20,7 @@ module Rubik
 
       def run_interactive
         @running = true
+        @interactive_prompt_loop = true
         multiline_buffer = []
         heredoc_delimiter = nil
         last_line_at = nil
@@ -33,6 +36,7 @@ module Rubik
           end
         end
       ensure
+        @interactive_prompt_loop = false
         stop
       end
 
@@ -45,7 +49,7 @@ module Rubik
         text = read_paste_block
         return { stop: false, buffer: [], delimiter: nil } if text.strip.empty?
 
-        execute_input(text)
+        submit_interactive_prompt(text)
         { stop: false, buffer: [], delimiter: nil }
       end
 
@@ -66,6 +70,7 @@ module Rubik
         flush_subagent_notices! if respond_to?(:flush_subagent_notices!)
         @terminal_guard&.flush_notices!
         current_prompt, boxed = prepare_prompt_line(!heredoc_delimiter.nil?)
+        restored_submission = !@prompt_restore.nil?
         line = safe_readline(current_prompt, add_history: false)
         @output.puts box_bottom_border if boxed
         return handle_eof(multiline_buffer, heredoc_delimiter) if line.nil? || line == "\x04" || line == "\x1a"
@@ -82,14 +87,14 @@ module Rubik
         # "instantly", so an ungated collector would swallow consecutive test
         # lines like "x = a << 1" + "exit" into one turn (seen in test_repl).
         now = paste_clock
-        if paste_burst_eligible? && !line.strip.empty? && !heredoc_delimiter &&
+        if !restored_submission && paste_burst_eligible? && !line.strip.empty? && !heredoc_delimiter &&
            multiline_buffer.empty? &&
            (paste_line_fast?(last_line_at, now) || paste_pending?)
           return collect_paste_burst(line)
         end
 
         # Push non-empty command to history
-        @reline::HISTORY.push(line) if !line.strip.empty? && line != begin
+        @reline::HISTORY.push(line) if !prompt_grace_interactive? && !line.strip.empty? && line != begin
           @reline::HISTORY.to_a.last
         rescue
           nil
@@ -152,13 +157,15 @@ module Rubik
           collector.call
         end
         text = lines.join("\n")
-        execute_input(text)
+        submit_interactive_prompt(text)
         # Return the final line timestamp so a following paste burst chain
         # (copy #2 right after copy #1) is still detected as fast lines.
         { stop: false, buffer: [], delimiter: nil, last_line_at: last_at }
       end
 
       def safe_readline(prompt, add_history: false)
+        return read_restored_prompt(prompt) if @prompt_restore
+
         if @terminal_guard
           @terminal_guard.with_reading { @reline.readline(prompt, add_history) }
         else
@@ -179,7 +186,7 @@ module Rubik
       def process_heredoc_line(line, multiline_buffer, heredoc_delimiter)
         if line.strip == heredoc_delimiter
           full_text = multiline_buffer.join("\n")
-          execute_input(full_text)
+          submit_interactive_prompt(full_text)
           { stop: false, buffer: [], delimiter: nil }
         else
           multiline_buffer << line
@@ -190,7 +197,7 @@ module Rubik
       def process_normal_line(line, _multiline_buffer)
         # Only trigger heredoc if line explicitly opens a multiline block (e.g. `<<EOF`, `!plan <<EOF`)
         # NEVER trigger on inline operators like `array << item` or `a << b`
-        heredoc_match = line.match(/^\s*(?:[a-zA-Z0-9_!.-]+\s+)?<<[-~]?['"]?([A-Za-z0-9_]+)['"]?\s*$/)
+        heredoc_match = line.match(/\A[ \t]*(?:[a-zA-Z0-9_!.-]+[ \t]+)?<<[-~]?['"]?([A-Za-z0-9_]+)['"]?[ \t]*\z/)
         if heredoc_match && !line.strip.start_with?("#")
           delimiter = heredoc_match[1]
           prefix = line.sub(/<<[-~]?['"]?#{Regexp.escape(delimiter)}['"]?\s*$/, "").strip
@@ -200,7 +207,7 @@ module Rubik
           stop
           { stop: true, buffer: [], delimiter: nil }
         else
-          execute_input(line)
+          submit_interactive_prompt(line)
           { stop: false, buffer: [], delimiter: nil }
         end
       end
@@ -208,6 +215,49 @@ module Rubik
       def process_multiline_or_line(line)
         execute_input(line)
       end
+
+      def prompt_grace_interactive?
+        @interactive_prompt_loop && !@replaying && interactive_input?
+      end
+
+      def submit_interactive_prompt(text)
+        return execute_input(text) unless prompt_grace_interactive?
+
+        if CommandParser.parse(text).type == :prompt
+          milliseconds = @config.fetch("ui.prompt_grace_window_ms", 1000)
+          outcome = PromptGrace.new(input: @input, output: @output,
+                                    context: @runtime_manager&.context).wait(milliseconds)
+          if outcome == :edit
+            @prompt_restore = text
+            return
+          end
+          return if outcome == :cancel
+        end
+        @reline::HISTORY.push(text) unless text.strip.empty? || @reline::HISTORY.to_a.last == text
+        execute_input(text)
+      end
+
+      def read_restored_prompt(prompt)
+        text = @prompt_restore
+        @prompt_restore = nil
+        previous = @reline.pre_input_hook
+        scope = @runtime_manager ? @runtime_manager.context.extend : Rubik::Runtime::Context.new
+        scope.on_dispose { @reline.pre_input_hook = previous }
+        @reline.pre_input_hook = lambda {
+          previous&.call
+          @reline.insert_text(text)
+        }
+        reader = -> { @reline.readmultiline(prompt, false) { true } }
+        if @terminal_guard
+          # A reactive wake must never inject Enter while Reline resets an
+          # apparently empty buffer, before the restoration hook fills it.
+          @terminal_guard.with_collecting { @terminal_guard.with_reading(&reader) }
+        else
+          reader.call
+        end
+      ensure
+        scope&.dispose
+      end
     end
   end
 end

data/lib/rubik/repl/prompt_grace.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "io/console"
+require "io/wait"
+require_relative "../runtime/context"
+
+module Rubik
+  module REPL
+    # Synchronous admission gate: no task, recorder entry or delayed callback
+    # exists until this returns :execute. A temporary context owns all terminal
+    # effects and is pruned from its parent on every exit.
+    class PromptGrace
+      ESCAPE_TIMEOUT = 0.03
+      STATUS = "Gönderiliyor… Esc: düzenlemeye dön"
+
+      def initialize(input:, output:, context: nil, clock: nil, reader: nil)
+        @input = input
+        @output = output
+        @context = context
+        @clock = clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+        @reader = reader || method(:read_byte)
+      end
+
+      def wait(milliseconds)
+        return :execute if milliseconds.zero?
+
+        scope = @context ? @context.extend : Rubik::Runtime::Context.new
+        mode = @input.console_mode
+        scope.on_dispose { @input.console_mode = mode }
+        @input.raw!
+        scope.on_dispose do
+          @output.print "\r\e[2K"
+          @output.flush
+        end
+        @output.print STATUS
+        @output.flush
+        deadline = @clock.call + (milliseconds / 1000.0)
+        loop do
+          remaining = deadline - @clock.call
+          if remaining <= 0
+            # A burst arriving at the deadline can leave bytes queued after
+            # the last processed key. Do not let its Enter submit a later turn.
+            if @input.respond_to?(:nread) && @input.nread.positive?
+              @input.iflush
+              @output.print "\a\r\e[2K[Rubik] Bekleme sırasında gelen tuşlar yok sayıldı.\r\n"
+            end
+            return :execute
+          end
+
+          byte = @reader.call(remaining)
+          next if byte.nil?
+          return :cancel if [:eof, "\x03"].include?(byte)
+
+          if byte == "\e"
+            escape = classify_escape
+            return escape unless escape == :sequence
+          end
+
+          # Other keys are intentionally rejected, with immediate feedback.
+          # Enter never leaks into the next readline as an accidental submit.
+          @output.print "\a\r\e[2K#{STATUS} · Tuş yok sayıldı"
+          @output.flush
+        end
+      rescue Interrupt
+        :cancel
+      ensure
+        scope&.dispose
+      end
+
+      private
+
+      def read_byte(timeout)
+        return nil unless @input.wait_readable(timeout)
+
+        @input.read_nonblock(1)
+      rescue IO::WaitReadable
+        nil
+      rescue EOFError
+        :eof
+      end
+
+      # CSI/SS3 arrows and function keys start with Esc too. Resolve this
+      # ambiguity even when Esc arrives just before the submission deadline.
+      def classify_escape
+        following = @reader.call(ESCAPE_TIMEOUT)
+        return :edit if following.nil? || following == :eof
+        return :cancel if following == "\x03"
+        return :sequence unless ["[", "O"].include?(following)
+
+        deadline = @clock.call + ESCAPE_TIMEOUT
+        loop do
+          remaining = deadline - @clock.call
+          break if remaining <= 0
+
+          byte = @reader.call(remaining)
+          return :cancel if byte == "\x03"
+          break if byte.nil? || byte == :eof || byte.match?(/[\x40-\x7e]/)
+        end
+        :sequence
+      end
+    end
+  end
+end

data/lib/rubik/repl/terminal_guard.rb

@@ -108,7 +108,11 @@ module Rubik
       # Plan 109: wake a blocked empty readline by injecting an Enter.
       # Reline 0.7.0's IO gates (ANSI/Windows/Dumb) all poll and re-check
       # their ungetc buffer (10ms/100ms/100ms), so the injection reaches
-      # the blocked reader on every gate. idle_and_empty? is re-evaluated
+      # the blocked reader on every gate. The per-poll re-check is 0.7.0+
+      # behavior — rubik.gemspec floors that version and
+      # test/integration/test_reline_wakeup_contract.rb pins the real gate
+      # (on 0.6.x the injected Enter strands until the next keystroke).
+      # idle_and_empty? is re-evaluated
       # inside this critical section (Monitor reentrancy makes the nested
       # synchronize free); the residual window between check and gate
       # consumption is inherent to Reline's thread model and accepted. A

data/lib/rubik/security/redactor.rb

@@ -23,6 +23,9 @@ module Rubik
       # PERF: Pre-compiled constants to avoid re-allocation inside hot loops
       URL_PATTERN = %r{(https?://[^:]+:)([^@]+)@}
       URL_MASK = "\\1#{MASK_STRING}@".freeze
+      STATIC_PATTERNS = PATTERNS.reject { |pattern| pattern == URL_PATTERN }.freeze
+      # Skip static replacement passes for assignment-only and URL-only inputs.
+      STATIC_PATTERNS_COMBINED_REGEX = Regexp.union(STATIC_PATTERNS).freeze
       QUICK_CHECK_REGEX = %r{sk-|AKIA|ghp_|github_pat_|AIza|bearer|PRIVATE KEY|://[^:]+:|password|passwd|api_key|secret|token}i
 
       # Anahtar-maskeleme desenleri (Session::Recorder#mask_payload ile aynı
@@ -46,13 +49,10 @@ module Rubik
         # ve desenler zaten bu metne uygulanıyordu, dolayısıyla eşdeğerdir.
         return result unless result.match?(QUICK_CHECK_REGEX)
 
-        PATTERNS.each do |pattern|
-          if pattern == URL_PATTERN
-            result.gsub!(pattern, URL_MASK)
-          else
-            result.gsub!(pattern, MASK_STRING)
-          end
-        end
+        # Keep replacement order: masking one credential can expose a word
+        # boundary needed to recognize the next (for example, a bearer token).
+        STATIC_PATTERNS.each { |pattern| result.gsub!(pattern, MASK_STRING) } if result.match?(STATIC_PATTERNS_COMBINED_REGEX)
+        result.gsub!(URL_PATTERN, URL_MASK)
 
         result.gsub!(ASSIGNMENT_KEY_REGEX) do
           "#{Regexp.last_match(1)}#{Regexp.last_match(2)}#{MASK_STRING}"

data/lib/rubik/storage/transcript_indexer.rb

@@ -26,23 +26,30 @@ module Rubik
         return unless store && inst
 
         file = inst.transcript_uri.to_s
+        result_ref = inst.respond_to?(:result_ref) ? inst.result_ref : nil
         # Gerçek upsert: alias üzerinden varsa mevcut id güncellenir — resume
         # sonrası ikinci tamamlanma yinelenen transcript varlığı yaratmaz.
         ref = Rubik::Uris.transcript_ref(inst.storage_id)
         existing = store.get(type: "transcript", id: ref)
+        links = {
+          "subagent_id" => inst.storage_id.to_s,
+          # The raw path is forensics-only (read_file denies it): the
+          # canonical read route rides in the entity itself so recall
+          # consumers land on show_file in one hop (issue #97 finding 5).
+          "canonical" => Rubik::Uris.subagent_transcript(inst.storage_id),
+          "transcript" => file
+        }
+        # Issue #122: the searchable summary also points at the paginated
+        # retained-result route. Availability is session-scoped (archive TTL),
+        # so this is a pointer with explicit expiration semantics, not a
+        # promise of unbounded retention.
+        links["result"] = result_ref if result_ref
         store.put(
           type: "transcript",
           title: "[#{inst.type_name}] #{inst.role} (#{inst.id}) — #{inst.state}",
-          body: entity_body(inst, file),
+          body: entity_body(inst, file, result_ref: result_ref),
           tags: [inst.type_name.to_s, inst.state.to_s].uniq,
-          links: {
-            "subagent_id" => inst.storage_id.to_s,
-            # The raw path is forensics-only (read_file denies it): the
-            # canonical read route rides in the entity itself so recall
-            # consumers land on show_file in one hop (issue #97 finding 5).
-            "canonical" => Rubik::Uris.subagent_transcript(inst.storage_id),
-            "transcript" => file
-          },
+          links: links,
           status: inst.state.to_s,
           id: existing&.[]("id"),
           ref: ref
@@ -59,7 +66,7 @@ module Rubik
       # gelmeyen her metin (prompt fallback, inst.result) HAM memory'den
       # gelir — kalıcı+aranabilir gövdeye girmeden Redactor'dan geçer
       # (dosya tarafının maskeleme paritesi; review bulgusu).
-      def entity_body(inst, file)
+      def entity_body(inst, file, result_ref: nil)
         task = first_user_task(file)
         task_part = if task
                       "[task] #{clip(task)}"
@@ -71,7 +78,10 @@ module Rubik
 
         result = inst.respond_to?(:result) ? redact(inst.result.to_s) : ""
         result_part = result.empty? ? "[state] #{inst.state} — no result recorded" : "[result] #{clip(result)}"
-        "#{task_part}\n#{result_part}"
+        body = "#{task_part}\n#{result_part}"
+        return body unless result_ref && inst.respond_to?(:state) && inst.state.to_s == "completed"
+
+        "#{body}\n[retrieve] #{result_ref} — full retained result, paginated (manage_subagents action 'result')"
       end
 
       def redact(text)