rubik 0.1.5 → 0.1.6

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "monitor"
+require "time"
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      # Operation-level telemetry (issue #126): what an execution is doing
+      # RIGHT NOW and how its time split between model waits and tool runs,
+      # measured with a monotonic clock (injectable for tests). Pure state —
+      # no IO, no notices, no locks shared with the instance; the status and
+      # wait surfaces read snapshots from here instead of guessing whether an
+      # execution is stalled.
+      class OperationTracker
+        MODEL = "model"
+        TOOL = "tool"
+        EMPTY_TIMINGS = { "model_seconds" => 0.0, "tool_seconds" => 0.0, "model_calls" => 0, "tool_calls" => 0 }.freeze
+
+        def initialize(clock: nil)
+          @clock = clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+          @monitor = Monitor.new
+          @current = nil
+          @timings = EMPTY_TIMINGS.dup
+          @last_progress_at = nil
+        end
+
+        # Marks the start of an in-flight operation. detail is already
+        # redacted/clipped by the caller (it is model-visible telemetry).
+        def start(kind, name: nil, detail: nil)
+          now = @clock.call
+          @monitor.synchronize do
+            @current = { kind: kind.to_s, name: name.to_s, detail: detail.to_s.empty? ? nil : detail.to_s,
+                         started_at: Time.now.utc.iso8601(3), started_monotonic: now }
+            @last_progress_at = now
+          end
+        end
+
+        # Ends the tracked operation and accumulates its duration into the
+        # matching model/tool bucket. Returns the elapsed seconds, or nil when
+        # the operation is not the one being tracked (e.g. after a reset).
+        def finish(kind)
+          @monitor.synchronize do
+            return nil unless @current && @current[:kind] == kind.to_s
+
+            elapsed = [@clock.call - @current[:started_monotonic], 0.0].max
+            bucket = kind.to_s == MODEL ? "model_seconds" : "tool_seconds"
+            counter = kind.to_s == MODEL ? "model_calls" : "tool_calls"
+            @timings[bucket] = (@timings[bucket] + elapsed).round(3)
+            @timings[counter] += 1
+            @current = nil
+            # Completing an operation is observable progress too.
+            @last_progress_at = @clock.call
+            elapsed
+          end
+        end
+
+        def progress!
+          now = @clock.call
+          @monitor.synchronize { @last_progress_at = now }
+        end
+
+        # A redeployed run is a new lineage: no stale operation, fresh buckets.
+        def reset!
+          @monitor.synchronize do
+            @current = nil
+            @timings = EMPTY_TIMINGS.dup
+            @last_progress_at = nil
+          end
+        end
+
+        # JSON-ready snapshot of the in-flight operation (nil when idle).
+        def current
+          @monitor.synchronize do
+            return nil unless @current
+
+            { kind: @current[:kind], name: @current[:name], detail: @current[:detail],
+              started_at: @current[:started_at],
+              elapsed_seconds: [@clock.call - @current[:started_monotonic], 0.0].max.round(3) }
+          end
+        end
+
+        def timings = @monitor.synchronize { @timings.dup }
+
+        def last_progress_seconds_ago
+          @monitor.synchronize do
+            @last_progress_at ? [@clock.call - @last_progress_at, 0.0].max.round(3) : nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "monitor"
+require_relative "../../security/redactor"
+require_relative "../../uris"
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      # Bounded, redacted, paginated access to completed run results (issue #122).
+      #
+      # Every existing surface truncates: an Instance keeps only the latest
+      # run's result under the terminal-only contract, wait rows show a 1500-char
+      # preview, transcript rendering and storage summaries have their own caps.
+      # This archive is the ONE retrieval contract for the remainder: each
+      # settled run's result is retained under an execution-specific reference
+      # (unique storage id + run sequence — redeploy runs never overwrite an
+      # earlier one), redacted at retention time, and served back in bounded
+      # pages with stable cursors (`has_more` / `next_cursor`).
+      #
+      # Reads are pure memory: no model call, no spawn/redeploy, no execution
+      # state change, no filesystem access (so no workspace allowlisting is
+      # involved). Retention is session-scoped and bounded by
+      # `subagents.result_archive.*` — newest `max_runs_per_instance` runs per
+      # execution, `ttl_seconds` lifetime — and unknown, evicted, or expired
+      # references answer explicitly instead of silently serving another run.
+      class ResultArchive
+        Entry = Struct.new(:ref, :storage_id, :id, :run, :state, :body, :retained_at, :expires_at, keyword_init: true)
+
+        Page = Struct.new(:ref, :storage_id, :id, :run, :state, :body, :cursor, :next_cursor,
+                          :total_chars, :returned_chars, :has_more, :redacted,
+                          :retained_at, :expires_at, keyword_init: true) do
+          def ok? = true
+        end
+
+        Missing = Struct.new(:ref, :reason, :message, keyword_init: true) do
+          def ok? = false
+        end
+
+        DEFAULT_TTL_SECONDS = 3600
+        DEFAULT_MAX_RUNS = 8
+        DEFAULT_PAGE_CHARS = 4000
+        MAX_PAGE_CHARS = 40_000
+
+        def initialize(config: nil, clock: nil, ttl_seconds: nil, max_runs_per_instance: nil, page_chars: nil)
+          @clock = clock || -> { Time.now }
+          @ttl_seconds = (ttl_seconds || config_get(config, "subagents.result_archive.ttl_seconds", DEFAULT_TTL_SECONDS)).to_f
+          @max_runs = (max_runs_per_instance || config_get(config, "subagents.result_archive.max_runs_per_instance", DEFAULT_MAX_RUNS)).to_i
+          @page_chars = (page_chars || config_get(config, "subagents.result_archive.page_chars", DEFAULT_PAGE_CHARS)).to_i
+          @max_runs = [@max_runs, 0].max
+          @page_chars = @page_chars.clamp(1, MAX_PAGE_CHARS)
+          @entries = {} # storage_id => { run => Entry }
+          @monitor = Monitor.new
+        end
+
+        # Retains one settled run's result. Redaction happens HERE (the raw
+        # in-memory history keeps its wire-faithful copy), the body is never
+        # mutated afterwards, and the run sequence keys the entry so a
+        # redeployed run cannot overwrite its predecessor.
+        def retain(storage_id:, id:, run:, state:, body:)
+          sid = storage_id.to_s
+          seq = [run.to_i, 1].max
+          now = @clock.call
+          entry = Entry.new(ref: Rubik::Uris.subagent_result(sid, run: seq), storage_id: sid, id: id.to_s,
+                            run: seq, state: state.to_s, body: Rubik::Security::Redactor.redact(body.to_s),
+                            retained_at: now, expires_at: now + @ttl_seconds)
+          @monitor.synchronize do
+            sweep_expired!(now)
+            runs = (@entries[sid] ||= {})
+            runs[seq] = entry
+            runs.delete(runs.keys.min) while runs.size > @max_runs
+          end
+          entry
+        end
+
+        # Bounded read by run (nil = latest retained run). Returns a Page on
+        # success — with cursor/next_cursor/has_more and explicit truncation
+        # metadata — or a Missing result with an explicit reason.
+        def read(storage_id:, run: nil, cursor: 0, limit: nil)
+          sid = storage_id.to_s
+          now = @clock.call
+          @monitor.synchronize do
+            runs = @entries[sid]
+            return missing(Rubik::Uris.subagent_result(sid, run: run&.to_i), :unknown, unknown_message(sid)) if runs.nil? || runs.empty?
+
+            entry = run ? runs[run.to_i] : runs[runs.keys.max]
+            unless entry
+              return missing(Rubik::Uris.subagent_result(sid, run: run.to_i), :unknown,
+                             "No retained run #{run} for execution '#{sid}' — retained run(s): #{runs.keys.sort.join(', ')}. #{retention_note}")
+            end
+
+            if expired?(entry, now)
+              runs.delete(entry.run)
+              @entries.delete(sid) if runs.empty?
+              return missing(entry.ref, :expired,
+                             "Retained result #{entry.ref} expired at #{entry.expires_at.utc.iso8601} (retention: #{@ttl_seconds.round}s). #{retention_note}")
+            end
+
+            page_for(entry, cursor, limit)
+          end
+        end
+
+        # Any non-expired retained entry for this execution id? Lets callers
+        # accept a raw storage id after the instance itself was reaped.
+        def known?(storage_id)
+          sid = storage_id.to_s
+          now = @clock.call
+          @monitor.synchronize do
+            runs = @entries[sid]
+            next false unless runs
+
+            runs.delete_if { |_run, entry| expired?(entry, now) }
+            !runs.empty?
+          end
+        end
+
+        def latest_run(storage_id)
+          @monitor.synchronize { (@entries[storage_id.to_s] || {}).keys.max }
+        end
+
+        # THE page rendering (tool action + rubik:// read share it, so the two
+        # access paths cannot drift). The continuation is the paginated API
+        # call — the reference itself always identifies the exact run.
+        def self.render_page(page, id: nil)
+          who = id || page.id
+          lines = ["Retained result #{page.ref} (run #{page.run}, state #{page.state}, execution '#{who}')",
+                   "chars #{page.cursor}-#{page.cursor + page.returned_chars} of #{page.total_chars}; " \
+                   "credentials redacted; expires #{page.expires_at&.utc&.iso8601}",
+                   "---", page.body, "---"]
+          lines << if page.has_more
+                     "More content follows — next page: manage_subagents(action: 'result', conversation_id: '#{who}', " \
+                       "run: #{page.run}, cursor: #{page.next_cursor})"
+                   else
+                     "(complete result)"
+                   end
+          lines.join("\n")
+        end
+
+        private
+
+        def page_for(entry, cursor, limit)
+          body = entry.body
+          total = body.length
+          cur = [cursor.to_i, 0].max
+          return missing(entry.ref, :cursor, "Cursor #{cur} exceeds the retained result length (#{total} chars). Use cursor 0.") if cur > total
+
+          size = limit.to_i
+          size = @page_chars if size <= 0
+          size = [size, MAX_PAGE_CHARS].min
+          text = body[cur, size].to_s
+          nxt = cur + text.length
+          has_more = nxt < total
+          Page.new(ref: entry.ref, storage_id: entry.storage_id, id: entry.id, run: entry.run, state: entry.state,
+                   body: text, cursor: cur, next_cursor: has_more ? nxt : nil, total_chars: total,
+                   returned_chars: text.length, has_more: has_more, redacted: true,
+                   retained_at: entry.retained_at, expires_at: entry.expires_at)
+        end
+
+        def missing(ref, reason, message)
+          Missing.new(ref: ref, reason: reason, message: message)
+        end
+
+        def unknown_message(sid)
+          "No retained result for execution '#{sid}'. #{retention_note}"
+        end
+
+        def retention_note
+          "The archive keeps the newest #{@max_runs} run(s) per execution for #{@ttl_seconds.round}s in this session; " \
+            "durable history remains in the subagent transcript."
+        end
+
+        def expired?(entry, now)
+          @ttl_seconds.positive? && entry.expires_at && entry.expires_at <= now
+        end
+
+        def sweep_expired!(now)
+          @entries.each do |sid, runs|
+            runs.delete_if { |_run, entry| expired?(entry, now) }
+            @entries.delete(sid) if runs.empty?
+          end
+        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/reuse.rb

@@ -52,7 +52,7 @@ module Rubik
         # ve taze scoped registry bağlanır (eskisinin ask_question'ı
         # dispose'lu ctx'e rebind'lıydı). Yeni görev history'ye user
         # mesajı olarak eklenir; run cycle yalnız BOŞ history seed eder.
-        def redeploy_for!(prompt:, max_steps:, context:, tool_registry:)
+        def redeploy_for!(prompt:, max_steps:, context:, tool_registry:, owner_task: nil)
           @monitor.synchronize do
             return false unless redeployable?
 
@@ -65,6 +65,13 @@ module Rubik
             # the old run's wait fact must not narrate the new one.
             @result = @last_error = @ended_at = @transcript_path = nil
             @pause_facts = nil
+            # Task ownership (issue #125): the redeployed run belongs to the
+            # CURRENT task's token (or stays detached); a fresh lineage is not
+            # born "cancelled by operator". Operation telemetry (#126) starts
+            # clean with it — no stale operation survives a redeploy.
+            @owner_task = owner_task
+            @cancelled_by_operator = false
+            @operations.reset!
             @context = context
             @tool_registry = tool_registry
             @context_cleaned_up = false
@@ -81,7 +88,10 @@ module Rubik
       # imkânsız — bkz. activation.rb). provider/buffer/provider_gate/
       # storage_id/kimlik AYNEN KALIR (reuse'un kendisi bu).
       module RedeploySupervisor
-        def redeploy(id, prompt:, max_steps: nil)
+        # `owner: :keep` (the default) keeps the instance's existing task
+        # ownership; the tool plane passes the CURRENT turn's token so a
+        # redeploy issued in this turn is cancellable with it (issue #125).
+        def redeploy(id, prompt:, max_steps: nil, owner: :keep)
           prompt_str = prompt.to_s.strip
           raise ArgumentError, "Redeploy prompt cannot be empty" if prompt_str.empty?
 
@@ -90,15 +100,18 @@ module Rubik
             inst = @instances[key] || (@finished || {})[key]
             raise ArgumentError, redeploy_refusal(key, inst) unless inst&.redeployable?
 
+            eff_owner = owner == :keep ? inst.owner_task : owner
+            refute_cancelled_owner!(eff_owner)
             validate_concurrency!
             child_ctx = extend_root_context!(:redeploy)
             scoped_registry = build_scoped_registry(@type_registry.get(inst.type_name), child_ctx, inst.buffer_manager)
             return false unless inst.redeploy_for!(prompt: prompt_str, max_steps: (max_steps || @default_max_steps).to_i,
-                                                   context: child_ctx, tool_registry: scoped_registry)
+                                                   context: child_ctx, tool_registry: scoped_registry,
+                                                   owner_task: eff_owner)
 
             @finished&.delete(inst.id)
             @instances[inst.id] = inst
-            activate_instance!(inst, child_ctx: child_ctx)
+            activate_instance!(inst, child_ctx: child_ctx, owner_token: eff_owner)
           end
           # SS bırakma kancası: redeploy da bir başlangıçtır — taze :running
           # flip'i, bu id'yi SS ile bekleyen kuyruk spesifikasyonlarını

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "transcript_formatter"
+require_relative "narration"
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      # The per-run entry/exit choreography, extracted from Instance to keep
+      # it under its module-hygiene cap (issue #122 added the run-sequence
+      # reference plumbing there): history seeding, the nil-provider terminal
+      # stub, the single failure drain, effective-prompt assembly and the
+      # durable transcript save belong to ONE vertical slice — a fresh run and
+      # a redeploy both enter through run_execution_cycle.
+      module RunCycle
+        # The human-readable rendering of the current history (public read
+        # seam; lives beside the durable-save choreography it mirrors).
+        def format_transcript
+          TranscriptFormatter.format(self, @history, @monitor)
+        end
+
+        private
+
+        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 Lifecycle::StateError => e
+          fail_run("LIFECYCLE INVARIANT VIOLATED: #{e.class}: #{e.message}")
+        rescue StandardError => e
+          fail_run("#{e.class}: #{e.message}")
+        end
+
+        # 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: the transcript URI is minted once at construction
+        # and every save mirrors the in-memory history (redacted at the file
+        # boundary) — callers own the retention decision, not the path.
+        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 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
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../../coeffects"
+
 module Rubik
   module Orchestrator
     module Subagent
@@ -51,14 +53,16 @@ module Rubik
           end
         end
 
-        # Subagent düzlemine geçen araçlar (ask_question + send_message):
-        # her ikisinin de coeffect çözümü yalnız child ctx'te sağlanır
+        # Subagent düzlemine geçen araçlar (ask_question + send_message +
+        # orchestration plane): coeffect çözümü yalnız child ctx'te sağlanır
         # (supervisor#spawn/redeploy provide). The rebind MUST precede the
         # buffer guard conceptually: research-type subagents inherit
         # workspace buffers, but ask_question still has to swap to the child
         # ctx — otherwise it would keep the ROOT tool (live shell) and pop a
         # HUMAN dialog from the worker thread; send_message swaps so the
-        # subagent-plane message carries its REAL sender id to the maestro.
+        # subagent-plane message carries its REAL sender id to the maestro;
+        # invoke/manage swap so a nested spawn resolves the INSTANCE's task
+        # token (issue #125) instead of the root turn's.
         # Class-matched (not name-matched): a plugin/dynamic tool registered
         # under the same name keeps its own implementation in every plane.
         def rebind_to_context(tool, ctx)
@@ -69,10 +73,18 @@ module Rubik
             Rubik::Tools::AskQuestionTool.new(shell: nil, runtime_context: ctx)
           when Rubik::Tools::SendMessageTool
             Rubik::Tools::SendMessageTool.new(runtime_context: ctx)
+          when Rubik::Tools::InvokeSubagentTool
+            Rubik::Tools::InvokeSubagentTool.new(supervisor: supervisor_for(ctx), runtime_context: ctx)
+          when Rubik::Tools::ManageSubagentsTool
+            Rubik::Tools::ManageSubagentsTool.new(supervisor: supervisor_for(ctx), runtime_context: ctx)
           else
             tool
           end
         end
+
+        def supervisor_for(ctx)
+          Rubik::Coeffects.get(ctx, Rubik::Coeffects::SUBAGENT_SUPERVISOR)
+        end
       end
     end
   end

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

@@ -2,7 +2,10 @@
 
 require "json"
 require_relative "../../prompt"
+require_relative "../../platform"
+require_relative "../../security/redactor"
 require_relative "../../tools/truncator"
+require_relative "../../uris"
 require_relative "../provider_recovery"
 require_relative "../auto_apply"
 require_relative "../tool_call_id"
@@ -13,6 +16,9 @@ require_relative "../../coeffects"
 require_relative "notices"
 require_relative "resilience"
 require_relative "conversation_id"
+require_relative "context_compaction"
+require_relative "operation_tracker"
+require_relative "tool_dispatch"
 
 module Rubik
   module Orchestrator
@@ -24,6 +30,9 @@ module Rubik
       # spine (agent-turn-executor plan); this module keeps the invocation path, budget
       # mechanics, and the subagent dispatch.
       module StepRunner
+        include ContextCompaction
+        include ToolDispatch
+
         # The shared response-processing spine, built lazily on first use so
         # objects that skip initialize (test doubles) stay safe.
         def turn_executor
@@ -78,21 +87,6 @@ module Rubik
           transition!(:failed)
         end
 
-        def evaluate_subagent_context_compaction!
-          return unless @context_limit&.positive?
-
-          context_cfg = ProviderRecovery.compaction_config(@config)
-          needs = Rubik::Prompt::ContextCompactor.needs_compaction?(
-            @history, context_limit: @context_limit, max_output_tokens: @max_output_tokens, config: context_cfg
-          )
-          return unless needs
-
-          compacted = Rubik::Prompt::ContextCompactor.compact_history(
-            @history, context_limit: @context_limit, max_output_tokens: @max_output_tokens, config: context_cfg
-          )
-          @history.replace(compacted)
-        end
-
         def invoke_provider_with_recovery(opts)
           ProviderRecovery.with_recovery(config: @config, compact: method(:emergency_compact_and_notify!)) do
             Resilience.retry_transient(config: @config, gate: @provider_gate) do
@@ -105,22 +99,6 @@ module Rubik
           @config.respond_to?(:fetch) ? @config.fetch("subagents.auto_pause_on_network_error", true) != false : true
         end
 
-        # Compaction actuator for the subagent path (mirrors Loop's public
-        # seam of the same name): the compaction body lives in
-        # TurnExecutor#emergency_compact! (one home for both channels); this
-        # delegates and the channel announces on the bus. Runs on the worker
-        # thread between monitor sections — never call it while holding
-        # @monitor (the emit stays lock-free).
-        def emergency_compact_and_notify!(reason)
-          turn_executor.emergency_compact!(reason)
-        end
-
-        # The object that owns the fact emits it — outside the monitor, so
-        # subscribers never run under the instance lock.
-        def emit_compacted_event(reason, layer)
-          Notices.emit(@event_bus, Notices::COMPACTED_EVENT, { id: @id, role: @role, state: @state, reason: reason.to_s, layer: layer })
-        end
-
         def invoke_provider(opts)
           effective_opts = opts.dup
           effective_opts[:timeout] ||= ProviderRecovery::SUBAGENT_REQUEST_TIMEOUT
@@ -128,10 +106,18 @@ module Rubik
           effective_opts[:context_limit] ||= @context_limit if @context_limit
           effective_opts[:max_tokens] ||= @max_output_tokens if @max_output_tokens&.positive?
 
-          return @provider.complete(@history, effective_opts) if @provider.respond_to?(:complete)
-          return @provider.chat(@history, **effective_opts) if @provider.respond_to?(:chat)
+          # Operation telemetry (issue #126): the model wait is observable
+          # while it lasts (status shows kind/name/elapsed) and its duration
+          # lands in the run's model bucket even when the call raises.
+          @operations.start(OperationTracker::MODEL, name: @model || "default")
+          begin
+            return @provider.complete(@history, effective_opts) if @provider.respond_to?(:complete)
+            return @provider.chat(@history, **effective_opts) if @provider.respond_to?(:chat)
 
-          raise "Provider #{@provider.class} does not support complete or chat"
+            raise "Provider #{@provider.class} does not support complete or chat"
+          ensure
+            @operations.finish(OperationTracker::MODEL)
+          end
         end
 
         def drain_inbox_into_history
@@ -155,10 +141,8 @@ module Rubik
         end
 
         # Single-call subagent dispatch (the TurnExecutor's per-call seam):
-        # pre-execution auto-apply, timed execution, and the canonical
-        # ToolHistory row — which now carries status + duration_ms like every
-        # other channel (the row-superset delta of the agent-turn-executor
-        # plan; no wire-side formatter reads them, observability only).
+        # pre-execution auto-apply, timed execution, the canonical ToolHistory
+        # row (status + duration_ms; observability only), and the #124 journal.
         def execute_subagent_tool_call(tool_call)
           name = tool_call["tool"]
           args = tool_call["args"] || {}
@@ -166,15 +150,39 @@ module Rubik
           canonical_name = tool ? tool.name : name.to_s.downcase
 
           auto_apply_buffer!(:pre_execution, tool: canonical_name)
-
-          t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          output, status = dispatch_subagent_tool(tool, name, args)
-          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(1)
+          # Journal the call BEFORE dispatch (issue #124): a crash inside the
+          # tool still leaves the attempted call correlated by its id. The
+          # operation snapshot (issue #126) shows the tool + redacted detail
+          # while it runs; the duration lands in the tool bucket either way.
+          @operations.start(OperationTracker::TOOL, name: canonical_name, detail: tool_detail(args))
+          @journal&.record_tool_call(run: @run_seq, call_id: tool_call["id"], tool: canonical_name, args: args)
+
+          result = nil
+          begin
+            result = dispatch_subagent_tool(tool, name, args)
+          ensure
+            elapsed = @operations.finish(OperationTracker::TOOL)
+          end
+          duration_ms = result.duration_ms.positive? ? result.duration_ms : ((elapsed || 0.0) * 1000).round(1)
+          @journal&.record_tool_result(run: @run_seq, call_id: tool_call["id"], tool: canonical_name,
+                                       status: result.status, duration_ms: duration_ms, output: result.output,
+                                       exit_code: result.exit_code, truncated: result.truncated,
+                                       artifact_ref: Rubik::Uris.subagent_transcript(@storage_id))
           Rubik::Orchestrator::ToolHistory.write(@history, tool_call_id: tool_call["id"], tool_name: name,
-                                                           status: status, duration_ms: duration_ms, content: output.to_s)
+                                                           status: result.status, duration_ms: duration_ms,
+                                                           content: result.output, exit_code: result.exit_code,
+                                                           metadata: result.metadata)
           nil
         end
 
+        # Redacted, clipped argument preview for the model-visible operation
+        # snapshot (issue #126): credentials are masked before they can reach
+        # status/wait output, and long payloads are bounded.
+        def tool_detail(args)
+          json = Rubik::Platform.safe_json_generate(Rubik::Security::Redactor.mask_value(args))
+          json.length > 120 ? "#{json[0, 120]}... [truncated]" : json
+        end
+
         # The subagent's own spelling of the shared auto-apply policy (AutoApply
         # owns the decision): decide, apply+sync through the coeffect shell,
         # and REPORT failures instead of swallowing them — a failed pre-test
@@ -208,30 +216,15 @@ module Rubik
           Rubik::Coeffects.get(@context, Rubik::Coeffects::SHELL)
         end
 
-        # Returns [truncated_output, status] so the dispatch site can build
-        # the canonical tool row. Unknown tools and execution errors carry
-        # :error; plain results are :ok (Result-backed tools carry their own).
-        def dispatch_subagent_tool(tool, name, args)
-          return ["Tool '#{name}' is not available in subagent toolset.", :error] unless tool
-
-          raw = tool.execute(args)
-          out_str = raw.respond_to?(:output) ? raw.output.to_s : raw.to_s
-          max_chars = (@config.respond_to?(:fetch) ? @config.fetch("tools.max_output_chars", 12_000) : 12_000) || 12_000
-          max_lines = (@config.respond_to?(:fetch) ? @config.fetch("tools.max_output_lines", 300) : 300) || 300
-          trunc = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars.to_i, max_lines: max_lines.to_i)
-          status = raw.respond_to?(:status) ? raw.status : :ok
-          [trunc[:text], status]
-        rescue StandardError => e
-          ["Tool execution error: #{e.class}: #{e.message}", :error]
-        end
-
         private
 
         # Plan 109 Faz A: per-step budget transparency replaces the 75%
         # warning latch — Budget owns the marker string under its lock; the
         # step loop owns only the history mutation (a conversation fact),
-        # the same split the warning used.
+        # the same split the warning used. The step boundary is also an
+        # observable progress point for the operation telemetry (#126).
         def inject_step_marker
+          @operations.progress!
           @history << { role: "user", content: @budget.step_marker }
         end
       end