rubik 0.1.4 → 0.1.6

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

@@ -5,6 +5,10 @@ require_relative "transcript_formatter"
 require_relative "storage_id"
 require_relative "lifecycle"
 require_relative "step_runner"
+require_relative "run_cycle"
+require_relative "journal"
+require_relative "teardown"
+require_relative "operation_tracker"
 require_relative "budget"
 require_relative "questioner"
 require_relative "reuse"
@@ -12,6 +16,7 @@ require_relative "notices"
 require_relative "narration"
 require_relative "resilience"
 require_relative "../../prompt"
+require_relative "../../uris"
 
 module Rubik
   module Orchestrator
@@ -23,11 +28,13 @@ module Rubik
         # transition!, and every predicate.
         include Lifecycle
         include StepRunner
+        include RunCycle
+        include Teardown
         include Questioner
         include Redeploy
         include Reaper
 
-        attr_accessor :parent_id, :unit
+        attr_accessor :parent_id, :unit, :owner_task
         # `state`: the sanctioned raw reader — display/serialization/kernel
         # bridge only; control flow asks the Lifecycle predicates. `result`
         # is TERMINAL-ONLY (real report / nil-provider stub); pauses narrate
@@ -36,7 +43,8 @@ module Rubik
                     :workspace, :model, :context, :tool_registry, :buffer_manager,
                     :state, :started_at, :ended_at, :result,
                     :last_error, :storage_id, :transcript_uri, :history,
-                    :context_limit, :max_output_tokens, :config, :pause_facts, :prompt_reconstructible
+                    :context_limit, :max_output_tokens, :config, :pause_facts, :prompt_reconstructible,
+                    :run_seq, :journal, :operations
 
         # Budget delegation: step counters live in Subagent::Budget (reader contract preserved).
         def current_step = @budget.current_step
@@ -46,7 +54,7 @@ module Rubik
                        system_prompt: nil, workspace: "inherit", model: "inherit",
                        provider: nil, buffer_manager: nil, max_steps: Budget::DEFAULT_MAX_STEPS, root_dir: Dir.pwd,
                        context_limit: nil, config: nil, event_bus: nil, provider_gate: nil, transcript_storage: nil,
-                       prompt_reconstructible: false)
+                       prompt_reconstructible: false, owner_task: nil)
           @id = id.to_s
           @parent_id = parent_id.to_s
           @role = role.to_s.strip
@@ -71,13 +79,26 @@ module Rubik
           @state = :pending
           @history = []
           @inbox = Queue.new
+          @owner_task = owner_task # issue #125: nil = explicitly detached (survives ^C)
+          @cancelled_by_operator = false
+          # Operation telemetry (issue #126): current operation + model/tool
+          # buckets, monotonic-clock based.
+          @operations = OperationTracker.new
           @started_at = @ended_at = @result = @last_error = @transcript_path = @pause_facts = nil
+          # Each run (initial or redeploy) owns a sequence number: it keys the
+          # retained-result reference so an earlier run's result is never
+          # overwritten by its redeploy (issue #122).
+          @run_seq = 0
           # Grant telemetry (session review B4/B11): grants consumed this run —
           # the halt message says "no FURTHER expansion" only when one landed.
           @grants_received = 0
           # SSOT (Plan 110): minted once; absorb (transcript_storage) kökü değiştirir.
           @storage_id = StorageId.mint(@id)
           @transcript_uri = TranscriptFormatter.mint_path(@root_dir, @storage_id, storage: transcript_storage)
+          # Append-only execution journal (issue #124): lands beside the
+          # transcript (absorbed or classic root), survives compaction and
+          # redeploys, bounded by subagents.journal.max_bytes.
+          @journal = Journal.new(path: File.join(File.dirname(@transcript_uri), Journal::FILENAME), config: @config)
           @monitor = Monitor.new
           @budget_cond = @monitor.new_cond
           @error_cond = @monitor.new_cond
@@ -87,6 +108,33 @@ module Rubik
 
         def uptime = @started_at ? ((@ended_at || Time.now) - @started_at).to_f : 0.0
 
+        # Execution-specific canonical reference to this run's retained result
+        # (issue #122): stable across reaping; the result archive answers
+        # explicitly when the run was never retained, evicted, or expired.
+        def result_ref
+          Rubik::Uris.subagent_result(@storage_id, run: @run_seq)
+        end
+
+        # Canonical transcript read reference (issue #123): ONE address for
+        # live memory and the persisted snapshot — the reader reports which
+        # snapshot it served. Bare display ids are not addresses.
+        def transcript_ref
+          Rubik::Uris.subagent_transcript(@storage_id)
+        end
+
+        # Immutable sequence snapshot under the instance lock: the read side of
+        # the transcript contract pages over a stable copy while the worker
+        # keeps appending (entries themselves are append-only after write).
+        def history_snapshot
+          @monitor.synchronize { @history.dup }
+        end
+
+        # Diagnostic pointers (issue #124): the append-only journal path and
+        # its last persistence failure (nil while healthy) — a failed journal
+        # write must be observable, never silently dropped.
+        def journal_path = @journal&.path
+        def journal_error = @journal&.last_error
+
         # Inbox girdisi: mesaj metni + GERÇEK gönderen id'si. nil veya makine
         # adı "agent-0" gönderenler render'da maestro persona'sına çevrilir
         # (iki-düzlem adlandırma sözleşmesi) — subagent gönderenler kendi
@@ -137,68 +185,45 @@ module Rubik
             return false if @thread&.alive?
 
             @started_at = Time.now
+            @run_seq += 1
             transition!(:running)
             @unit&.sync_state!
+            @journal&.record_run_started(run: @run_seq, role: @role, type: @type_name, prompt: @prompt)
           end
 
+          ready = Queue.new
+          run_gate = Queue.new
           @thread = Thread.new do
-            run_execution_cycle
-          ensure
-            @ended_at ||= Time.now
-            save_transcript! if @transcript_path.nil?
-            cleanup_context
-            on_complete&.call(self)
-          end
-          true
-        end
-
-        def kill
-          @monitor.synchronize do
-            return true if disposed?
-
-            transition!(:canceling)
-            @ended_at = Time.now
-            @budget_cond.broadcast
-            @error_cond.broadcast
-          end
-
-          begin; @thread&.kill if @thread&.alive?; rescue StandardError; nil; end
-
-          cleanup
-          true
-        end
-
-        def cleanup
-          @monitor.synchronize do
-            return if disposed?
-
-            @budget_cond.broadcast
-            @error_cond.broadcast
-            cleanup_context
-            transition!(:disposed)
-          end
-        end
-
-        # Idempotent under monitor: check-and-set of @context_cleaned_up (ensure block vs kill cleanup race).
-        def cleanup_context
-          @monitor.synchronize do
-            return if @context_cleaned_up
-
-            @context_cleaned_up = true
-            begin
-              @context&.dispose unless @context&.disposed?
-            rescue StandardError => e
-              @last_error ||= "#{e.class}: #{e.message}"
+            Thread.handle_interrupt(Object => :never) do
+              ready << true # cleanup is armed before cancellation is enabled
+              Thread.handle_interrupt(Object => :immediate) do
+                run_gate.pop
+                run_execution_cycle
+              end
+            ensure
+              @ended_at ||= Time.now
+              @journal&.record_run_finished(run: @run_seq, state: @state.to_s, result: @result,
+                                            result_ref: (result_ref if settled?))
+              save_transcript! if @transcript_path.nil?
+              @cancelled_by_operator ? cleanup : cleanup_context
+              on_complete&.call(self)
             end
           end
+          ready.pop
+          run_gate << true
+          true
         end
 
         def to_h
           @monitor.synchronize do
             { id: @id, parent_id: @parent_id, role: @role, type: @type_name, state: @state.to_s,
-              **@budget.to_h, grants_received: @grants_received, uptime_seconds: uptime.round(2),
+              **@budget.to_h, grants_received: @grants_received, run: @run_seq,
+              result_ref: result_ref, owner: @owner_task&.id, detached: @owner_task.nil?, uptime_seconds: uptime.round(2),
+              operation: operations.current, timings: operations.timings,
+              last_progress_seconds_ago: operations.last_progress_seconds_ago,
               started_at: @started_at&.iso8601, ended_at: @ended_at&.iso8601,
-              transcript: @transcript_uri, last_error: @last_error,
+              transcript: @transcript_uri, transcript_ref: transcript_ref,
+              journal: journal_path, journal_error: journal_error, last_error: @last_error,
               result_summary: @result&.to_s&.slice(0, 100), result: @result, state_note: state_note }
           end
         end
@@ -211,60 +236,14 @@ module Rubik
           end
         end
 
-        def format_transcript
-          TranscriptFormatter.format(self, @history, @monitor)
-        end
-
         private
 
-        # The run's single failure drain: record why, land on :failed, sync
-        # the unit, persist — the loud prefix keeps an FSM violation
-        # distinguishable from a provider failure.
-        def fail_run(reason)
-          @monitor.synchronize do
-            @last_error = reason
-            transition!(:failed)
-            @unit&.sync_state!
-          end
-          save_transcript!
-        end
-
         # Private by design: a grant must pair with the terminal guard, the
         # history note, and the broadcast — all lifecycle facts owned here.
         # Tests drive budget states through supervisor + provider, never by
         # reaching into this reader.
         attr_reader :budget
 
-        def save_transcript!
-          saved = TranscriptFormatter.save!(@transcript_uri, @history, @monitor,
-                                            prompt_reconstructible: @prompt_reconstructible)
-          @transcript_path = saved
-          # A failed save must not be silent: the advertised path would 404 silently.
-          @last_error ||= "Transcript save failed for #{@transcript_uri}: see stderr" unless saved
-        end
-
-        def run_execution_cycle
-          # Fresh runs seed; a redeployed run continues its preserved history.
-          @history.push({ role: "system", content: build_effective_system_prompt }, { role: "user", content: @prompt }) if @history.empty?
-
-          unless @provider
-            @budget.consume
-            @result = Narration.completed_stub_line(@id, @role, @prompt)
-            transition!(:completed)
-            @unit&.sync_state!
-            save_transcript!
-            return
-          end
-
-          execute_steps_with_provider
-          @unit&.sync_state!
-          save_transcript!
-        rescue StateError => e
-          fail_run("LIFECYCLE INVARIANT VIOLATED: #{e.class}: #{e.message}")
-        rescue StandardError => e
-          fail_run("#{e.class}: #{e.message}")
-        end
-
         # The single budget-grant core (Candidate 03): terminal guard ->
         # grant -> resume -> note -> broadcast. Note wording lives in
         # Budget.grant_note/message_grant_note (audience boundary: the
@@ -366,18 +345,6 @@ module Rubik
             end
           end
         end
-
-        def build_effective_system_prompt
-          base = "You are a specialized subagent operating under autonomous supervision.\n\n" \
-                 "Subagent ID: #{@id} | Role: #{@role} | Type: #{@type_name}\n" \
-                 "Allocated Step Budget: #{@budget.max_steps} steps.\n\n" \
-                 "A [Step X/Y] status line precedes each of your steps (X = current step, Y = total budget). Pace yourself: " \
-                 "when remaining steps (Y - X) run low, conclude the task or prepare a progress summary for the maestro " \
-                 "supervisor — it may extend your budget or steer you. If a requirement is genuinely ambiguous, ask the maestro directly with the " \
-                 "ask_question tool — it blocks until the maestro answers or times out; ask only when the answer truly changes your work.\n\n" \
-                 "Perform your assigned task with high precision and provide a structured synthesis report."
-          @system_prompt && !@system_prompt.strip.empty? ? "#{base}\n\nCustom Instructions:\n#{@system_prompt}" : base
-        end
       end
     end
   end

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

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "json"
+require "monitor"
+require "time"
+require "fileutils"
+require_relative "../../platform"
+require_relative "../../security/redactor"
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      # Append-only, redacted execution journal (issue #124).
+      #
+      # The durable transcript is a CONVERSATION SNAPSHOT: save! rewrites it
+      # from the current mutable history, so once compaction replaces earlier
+      # steps with a summary marker the pre-compaction events are gone from it.
+      # This journal is the complementary artifact: every lifecycle,
+      # tool-call, tool-result and compaction event is appended BEFORE the
+      # history can be pruned, records are never rewritten, and a redeployed
+      # run continues the same file distinguished by its run sequence.
+      #
+      # Retention is bounded independently of the model context: at most
+      # `subagents.journal.max_bytes` per execution file. Once the cap is
+      # reached a final `journal_truncated` record marks the boundary and
+      # further events are not persisted (a cancellation outcome is recorded
+      # when the handler can still write one). Tool payloads are previewed
+      # (PREVIEW_CHARS) with explicit `output_chars` / `output_truncated`
+      # metadata plus an `artifact_ref` to the conversation snapshot, so replay
+      # can distinguish originals from summaries from clipped output.
+      #
+      # Every record passes through Redactor.mask_value before it reaches the
+      # file — credentials are redacted before persistence, never after. A
+      # crash mid-append can leave a partial last line; Journal.read skips
+      # malformed rows and reports them, so earlier valid records always stay
+      # readable. Write failures are observable through #last_error (surfaced
+      # in Instance#to_h), never raised into the run.
+      class Journal
+        FILENAME = "journal.jsonl"
+        DEFAULT_MAX_BYTES = 2_097_152
+        # Headroom kept free for the final truncation marker: accepted records
+        # never consume the last bytes, so the marker always fits inside the cap.
+        MARKER_RESERVE = 512
+        MIN_MAX_BYTES = 1024
+        PREVIEW_CHARS = 4000
+        ARGS_CHARS = 2000
+        PROMPT_CHARS = 400
+
+        Read = Struct.new(:records, :skipped, :truncated, :error, keyword_init: true)
+
+        attr_reader :path
+
+        def initialize(path:, config: nil)
+          @path = path.to_s
+          @monitor = Monitor.new
+          @max_bytes = [config_get(config, "subagents.journal.max_bytes", DEFAULT_MAX_BYTES).to_i, MIN_MAX_BYTES].max
+          @seq = self.class.read(@path).records.length
+          @bytes = File.exist?(@path) ? File.size(@path) : 0
+          @closed = false
+          @last_error = nil
+        end
+
+        # The generic append core: sequence, run, timestamp and type are the
+        # record envelope; the payload is masked HERE (single redaction gate).
+        def append(event, run: 1, data: {}, call_id: nil)
+          @monitor.synchronize do
+            return nil if @closed
+
+            @last_run = run.to_i
+            row = { "seq" => @seq + 1, "run" => @last_run, "ts" => Time.now.utc.iso8601(3),
+                    "event" => event.to_s, "data" => Rubik::Security::Redactor.mask_value(data) }
+            row["call_id"] = call_id.to_s if call_id
+            line = "#{Rubik::Platform.safe_json_generate(row)}\n"
+            if @bytes + line.bytesize + MARKER_RESERVE > @max_bytes
+              mark_truncated
+              return nil
+            end
+            return nil unless write!(line)
+
+            @seq += 1
+            @bytes += line.bytesize
+            row
+          end
+        end
+
+        # --- semantic record vocabulary (the only place event shapes live) ---
+
+        def record_run_started(run:, role:, type:, prompt:)
+          data = { "role" => role.to_s, "type" => type.to_s, "prompt_preview" => clip(prompt, PROMPT_CHARS) }
+          append("run_started", run: run, data: data)
+        end
+
+        def record_run_finished(run:, state:, result: nil, result_ref: nil)
+          text = result.to_s
+          data = { "state" => state.to_s, "result_chars" => text.length,
+                   "result_preview" => clip(text, PROMPT_CHARS), "result_ref" => result_ref }.compact
+          append("run_finished", run: run, data: data)
+        end
+
+        def record_cancelled(run:, reason: nil)
+          append("cancelled", run: run, data: { "reason" => reason.to_s })
+        end
+
+        def record_tool_call(run:, call_id:, tool:, args:)
+          json = Rubik::Platform.safe_json_generate(Rubik::Security::Redactor.mask_value(args))
+          data = { "tool" => tool.to_s, "args_chars" => json.length }
+          if json.length > ARGS_CHARS
+            data["args_truncated"] = true
+            data["args_preview"] = clip(json, ARGS_CHARS)
+          else
+            data["args"] = args
+          end
+          append("tool_call", run: run, call_id: call_id, data: data)
+        end
+
+        def record_tool_result(run:, call_id:, tool:, status:, duration_ms:, output:, artifact_ref: nil, exit_code: nil,
+                               truncated: false)
+          text = output.to_s
+          data = { "tool" => tool.to_s, "status" => status.to_s, "exit_code" => exit_code, "duration_ms" => duration_ms,
+                   "output_chars" => text.length, "output_truncated" => truncated || text.length > PREVIEW_CHARS,
+                   "output_preview" => clip(text, PREVIEW_CHARS), "artifact_ref" => artifact_ref }.compact
+          append("tool_result", run: run, call_id: call_id, data: data)
+        end
+
+        def record_compaction(run:, layer:, reason: nil, before: nil, after: nil)
+          data = { "layer" => layer.to_s, "reason" => reason.to_s.slice(0, 200),
+                   "history_before" => before, "history_after" => after }.compact
+          append("compaction", run: run, data: data)
+        end
+
+        # Tolerant reader: malformed rows (an interrupted final write included)
+        # are skipped and COUNTED — one partial line never hides valid history.
+        def self.read(path)
+          records = []
+          skipped = 0
+          return Read.new(records: records, skipped: skipped, truncated: false) unless File.exist?(path)
+
+          File.foreach(path, encoding: "UTF-8") do |line|
+            next if line.strip.empty?
+
+            row = begin
+              JSON.parse(line.scrub)
+            rescue JSON::ParserError
+              nil
+            end
+            if row.is_a?(Hash) && row["seq"]
+              records << row
+            else
+              skipped += 1
+            end
+          end
+          Read.new(records: records, skipped: skipped,
+                   truncated: records.any? { |r| r["event"] == "journal_truncated" })
+        rescue StandardError => e
+          Read.new(records: records, skipped: skipped + 1, truncated: false, error: e)
+        end
+
+        def read = self.class.read(@path)
+
+        # The last persistence failure (nil while healthy) — read under the
+        # journal lock so Instance#to_h never observes a half-written value.
+        def last_error = @monitor.synchronize { @last_error }
+
+        private
+
+        def mark_truncated
+          @closed = true
+          marker = { "seq" => @seq + 1, "run" => (@last_run || 1).to_i, "ts" => Time.now.utc.iso8601(3),
+                     "event" => "journal_truncated",
+                     "data" => { "max_bytes" => @max_bytes, "reason" => "retention cap reached; further events are not journaled" } }
+          line = "#{Rubik::Platform.safe_json_generate(marker)}\n"
+          return nil if @bytes + line.bytesize > @max_bytes || !write!(line)
+
+          @seq += 1
+          @bytes += line.bytesize
+          nil
+        end
+
+        def write!(line)
+          FileUtils.mkdir_p(File.dirname(@path))
+          File.write(@path, line, mode: "a")
+          true
+        rescue StandardError => e
+          @last_error = "#{e.class}: #{e.message}"
+          false
+        end
+
+        def clip(text, limit)
+          value = Rubik::Security::Redactor.redact(text.to_s)
+          value.length > limit ? "#{value[0, limit]}... [truncated #{value.length - limit} chars]" : value
+        end
+
+        def config_get(config, key, default)
+          return default if config.nil?
+
+          val = if config.is_a?(Hash)
+                  config[key] || config.dig(*key.split("."))
+                elsif config.respond_to?(:fetch)
+                  config.fetch(key, nil)
+                end
+          val.nil? ? default : val
+        end
+      end
+    end
+  end
+end

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

@@ -74,6 +74,19 @@ module Rubik
           end
         end
 
+        # Wait-return narration (issue #126): WHY the wait returned, as the next
+        # actionable fact; nil for a settled wait (no story to tell).
+        WAIT_REASON_HINTS = {
+          deadline: "Deadline reached while subagent(s) remain ACTIVE — they keep running; wait again with a longer timeout or conclude your turn.",
+          paused: "Subagent(s) are paused and need an action (extend_budget / resume / answer their question) before the chain continues.",
+          queued: "Only dependency-queued work remains — it launches automatically once its predecessors settle; no action needed.",
+          unknown: "No such subagent id(s) — check the roster with manage_subagents(action: 'list')."
+        }.freeze
+
+        def wait_reason_hint(reason)
+          WAIT_REASON_HINTS[reason.to_sym]
+        end
+
         # The nil-provider fast path's terminal stub (a legitimate outcome:
         # no provider, no story beyond the echo of the task itself).
         def completed_stub_line(id, role, prompt)
@@ -93,6 +106,7 @@ module Rubik
           Action.new(canonical: "status", aliases: [], param: "conversation_id"),
           Action.new(canonical: "wait", aliases: [], param: "conversation_ids"),
           Action.new(canonical: "transcript", aliases: [], param: "conversation_id"),
+          Action.new(canonical: "result", aliases: [], param: "conversation_id"),
           Action.new(canonical: "extend_budget", aliases: ["grant_steps", "extend"], param: "conversation_id"),
           Action.new(canonical: "resume", aliases: ["retry"], param: "conversation_id"),
           Action.new(canonical: "redeploy", aliases: [], param: "conversation_id"),

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

@@ -6,9 +6,8 @@ require_relative "budget"
 module Rubik
   module Orchestrator
     module Subagent
-      # THE single vocabulary home for subagent notices: event names and
-      # payloads enter, two channel renderings leave (user channel: REPL
-      # hints allowed; model channel: tool-oriented).
+      # THE single vocabulary home for subagent notices: event names and payloads
+      # enter, two channel renderings leave (user: REPL hints; model: tool-oriented).
       module Notices
         module_function
 
@@ -34,11 +33,8 @@ module Rubik
         # Sessizlik (§4.3): bu roller notice ÜRETMEZ, yalnız dmesg'e düşer (Distiller + Context Pruner).
         SILENT_ROLES = ["Vakanüvis Distiller", "Context Pruner"].freeze
 
-        # Dmesg-plane emission metadata (bug-llm-timeout-observability): every
-        # subagent-plane event lands in the ring under subsystem :subagent with
-        # an operational-weight severity, so dmesg(level:/subsystem:) surfaces
-        # a stalled subagent. MESSAGE_EVENT routes here too (a :message notice
-        # via handle_parent_message, not normalize).
+        # Dmesg-plane metadata (bug-llm-timeout-observability): subagent-plane events
+        # land in the ring under subsystem :subagent with an operational-weight severity.
         SUBSYSTEM = :subagent
 
         SEVERITIES = {
@@ -51,12 +47,11 @@ module Rubik
           MESSAGE_EVENT => :info
         }.freeze
 
-        # The one emission door: severity and subsystem are decided HERE,
-        # never re-derived at call sites. Nil bus = the old `&.emit` skip;
-        # a bus lacking #emit still raises loud; a legacy 2-arity emit gets
-        # a plain 2-arg call (severity metadata best-effort, delivery
-        # load-bearing). `fallback:` flips a raise into a stderr warn (the
-        # AutoApply.report_failure pattern) for load-bearing event sites.
+        # The one emission door: severity and subsystem are decided HERE, never
+        # re-derived at call sites. Nil bus = the old `&.emit` skip; a bus lacking
+        # #emit still raises loud; a legacy 2-arity emit gets a plain 2-arg call
+        # (severity metadata best-effort, delivery load-bearing). `fallback:`
+        # flips a raise into a stderr warn (AutoApply.report_failure pattern).
         def emit(bus, event_name, payload, fallback: nil)
           return if bus.nil?
 
@@ -92,11 +87,12 @@ module Rubik
             notice[:reason] = raw_err.to_s.slice(0, kind == :question ? 300 : 120)
           end
           notice[:timeout] = payload[:timeout] if kind == :question
+          # Kanonik referanslar (#122/#129): sonuç + transcript okuma adresleri bildirimle taşınır.
+          notice[:result_ref] = payload[:result_ref].to_s if payload[:result_ref]
+          notice[:transcript_ref] = payload[:transcript_ref].to_s if payload[:transcript_ref]
           # B11: grant/step markers make repeated pauses distinguishable.
-          if kind == :budget_exhausted
-            notice[:grants] = payload[:grants].to_i if payload[:grants].to_i.positive?
-            notice[:step] = payload[:step].to_i if payload[:step].to_i.positive?
-          end
+          notice[:grants] = payload[:grants].to_i if kind == :budget_exhausted && payload[:grants].to_i.positive?
+          notice[:step] = payload[:step].to_i if kind == :budget_exhausted && payload[:step].to_i.positive?
           notice
         end
 
@@ -109,8 +105,7 @@ module Rubik
             "⚠️ [Subagent Auto-Apply] [#{notice[:id]}] '#{notice[:role]}' could not auto-apply its buffer (#{notice[:reason]}). Changes remain unapplied."
           when :budget_exhausted
             grants = notice[:grants].to_i
-            step = notice[:step]
-            cyc = " again (after #{grants} grant(s) consumed#{", at step #{step}" if step})" if grants.positive?
+            cyc = " again (after #{grants} grant(s) consumed#{", at step #{notice[:step]}" if notice[:step]})" if grants.positive?
             "⚠️ [Subagent Paused] [#{notice[:id]}] '#{notice[:role]}' reached step budget#{cyc} " \
               "(#{notice[:max_steps]} steps). Run '!subagents extend #{notice[:id]}' to resume."
           when :error_paused
@@ -140,6 +135,8 @@ module Rubik
         def model_element(notice)
           attrs = { kind: notice[:kind], id: notice[:id], role: notice[:role], state: notice[:state] }
           attrs[:max_steps] = notice[:max_steps] if notice[:kind] == :budget_exhausted
+          attrs[:result_ref] = notice[:result_ref] if notice[:result_ref]
+          attrs[:transcript_ref] = notice[:transcript_ref] if notice[:transcript_ref]
           reason_kinds = [:context_compacted, :auto_apply_failed, :error_paused, :message, :task, :question]
           attrs[:reason] = notice[:reason] if reason_kinds.include?(notice[:kind]) && !notice[:reason].to_s.empty?
           attrs[:timeout] = notice[:timeout] if notice[:kind] == :question && notice[:timeout]
@@ -177,8 +174,10 @@ module Rubik
           else
             if notice[:state] == "budget_exhausted"
               budget_exhausted_line(notice[:max_steps])
+            elsif notice[:state] == "cancelled"
+              "The task was cancelled (^C): this execution will produce no result. Spawn a fresh subagent if the work is still needed."
             else
-              "Retrieve the full result with #{wait_hint(notice[:id])}."
+              "Retrieve the full result with #{notice[:result_ref].to_s.empty? ? wait_hint(notice[:id]) : "read_file(path: '#{notice[:result_ref]}')"}."
             end
           end
         end