rubik 0.1.5 → 0.2.0

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

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

@@ -2,8 +2,13 @@
 
 require "monitor"
 require_relative "../../platform"
+require_relative "../task_cancellation"
 require_relative "type_registry"
 require_relative "instance"
+require_relative "result_archive"
+require_relative "execution_reads"
+require_relative "task_ownership"
+require_relative "waiting"
 require_relative "reuse"
 require_relative "notices"
 require_relative "concurrency_gate"
@@ -19,6 +24,10 @@ module Rubik
     module Subagent
       class DepthExceededError < StandardError; end
       class ConcurrencyExceededError < StandardError; end
+      # New owned work after task cancellation (issue #125): the owner's token
+      # is already cancelled — spawning into it would violate "no pending owned
+      # descendant starts after cancellation".
+      class TaskCancelledError < StandardError; end
 
       # Root Supervisor Agent governing the entire subagent process hierarchy:
       # this class models Linux init's PID-1 supervisory ROLE (parent of the
@@ -26,7 +35,8 @@ module Rubik
       # `agent-0`). Also owns concurrent pool limits and LIFO shutdown (Plan 94).
       class Supervisor
         attr_accessor :tool_registry, :router, :init
-        attr_reader :root_context, :type_registry, :instances, :max_depth, :max_concurrency, :default_max_steps, :provider_gate
+        attr_reader :root_context, :type_registry, :instances, :max_depth, :max_concurrency, :default_max_steps,
+                    :provider_gate, :result_archive
 
         include RedeploySupervisor
         include ReaperSupervisor
@@ -34,6 +44,9 @@ module Rubik
         include DependencySupervisor
         include MessagingSupervisor
         include ActivationSupervisor
+        include ExecutionReads
+        include TaskOwnershipSupervisor
+        include WaitSupervisor
 
         def initialize(root_context:, buffer_manager: nil, tool_registry: nil,
                        provider: nil, router: nil, config: nil, root_dir: Dir.pwd, event_bus: nil, init: nil)
@@ -57,6 +70,9 @@ module Rubik
           @default_max_steps = (config&.fetch("subagents.default_max_steps", Budget::DEFAULT_MAX_STEPS) || Budget::DEFAULT_MAX_STEPS).to_i
           @provider_concurrency = (config&.fetch("subagents.provider_concurrency", 2) || 2).to_i
           @provider_gate = ConcurrencyGate.new(@provider_concurrency)
+          # Retained completed-run results (issue #122): session-scoped,
+          # redacted, paginated — see ResultArchive.
+          @result_archive = ResultArchive.new(config: @config)
 
           # Register inverse in root context (maestro hook)
           @root_context.register_disposable { shutdown_all } if @root_context.respond_to?(:register_disposable)
@@ -64,18 +80,23 @@ module Rubik
 
         def spawn(role:, prompt:, type_name: "research", system_prompt: nil,
                   parent_id: ConversationId::ROOT_ID, workspace: "inherit", model: "inherit",
-                  max_steps: nil, provider: nil, depends_on: nil, reserved_id: nil)
+                  max_steps: nil, provider: nil, depends_on: nil, reserved_id: nil, owner: nil)
           role_str = role.to_s.strip
           prompt_str = prompt.to_s.strip
           raise ArgumentError, "Subagent role cannot be empty" if role_str.empty?
           raise ArgumentError, "Subagent prompt cannot be empty" if prompt_str.empty?
 
+          # Issue #125: the owner's task was cancelled — refuse before any
+          # reservation, slot or context work happens.
+          refute_cancelled_owner!(owner)
+
           # Bağımlı spec doğrudan spawn edilmez: kuyruğa girer (FS/SS
           # kısıtı), bırakma süpürmesi gerçek koreografiyi oynatır.
           if depends_on
             return spawn_batch([{ role: role_str, prompt: prompt_str, type_name: type_name,
                                   system_prompt: system_prompt, parent_id: parent_id, workspace: workspace,
-                                  model: model, max_steps: max_steps, provider: provider, depends_on: depends_on }]).first[1]
+                                  model: model, max_steps: max_steps, provider: provider, depends_on: depends_on }],
+                               owner: owner).first[1]
           end
 
           created = @monitor.synchronize do
@@ -107,12 +128,12 @@ module Rubik
               provider: prov, buffer_manager: effective_buffer, max_steps: (max_steps || @default_max_steps).to_i,
               provider_gate: @provider_gate, root_dir: @root_dir, config: @config,
               context_limit: (@config.respond_to?(:fetch) ? @config.fetch("context.max_tokens", 32_768) : 32_768),
-              event_bus: @event_bus, transcript_storage: absorb_storage,
+              event_bus: @event_bus, transcript_storage: absorb_storage, owner_task: owner,
               prompt_reconstructible: prompt_reconstructible
             )
 
             @instances[subagent_id] = inst
-            activate_instance!(inst, child_ctx: child_ctx)
+            activate_instance!(inst, child_ctx: child_ctx, owner_token: owner)
             inst
           end
           # SS bırakma kancası: yeni başlayan instance, onu bekleyen kuyruk
@@ -121,30 +142,6 @@ module Rubik
           created
         end
 
-        def wait_for(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) }
-            candidates.map(&:to_h)
-          end
-        end
-
         # Tombstone + kuyruk dahil arama: reap/rezervasyon sonrası da
         # status/transcript/list sorgulanır.
         def get(id) = @monitor.synchronize { @instances[id.to_s] || (@finished ||= {})[id.to_s] || queued_spec(id.to_s) }

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "../task_cancellation"
+require_relative "notices"
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      # Task ownership and cancellation choreography (issue #125). The
+      # supervisor already knows every execution; this seam answers "which
+      # executions belong to this token" and stops exactly those. Work that was
+      # explicitly detached carries its own never-cancelled token and work
+      # spawned under a different turn carries a different token, so both are
+      # untouched by construction.
+      #
+      # The outcome reports the three states the UI needs: cancellation
+      # requested (the token), complete (nothing remains), and incomplete
+      # cleanup (threads that did not settle inside the grace period — they are
+      # force-killed AND named, so a stuck execution is never silently lost).
+      module TaskOwnershipSupervisor
+        CancellationOutcome = Struct.new(:cancelled, :stopped, :remaining, :queued_cancelled, keyword_init: true) do
+          def any? = !(stopped.empty? && remaining.empty? && queued_cancelled.empty?)
+          def complete? = remaining.empty?
+        end
+
+        # Request termination on each owned worker, then wait for cleanup up to
+        # the configured grace period and report the remainder. Queued specs of the
+        # token are cancelled before they ever start.
+        def cancel_owned(token, timeout: nil)
+          return CancellationOutcome.new(cancelled: false, stopped: [], remaining: [], queued_cancelled: []) unless token
+
+          token.cancel!("foreground task cancelled (^C)")
+          deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + [timeout.to_f, 0.0].max
+          queued = cancel_queued_specs(token)
+          requested = {}
+          loop do
+            targets = @monitor.synchronize do
+              @instances.values.select { |inst| owned_by?(inst, token) && !cancellation_settled?(inst) }
+            end
+            targets.each do |inst|
+              next if requested[inst.id]
+
+              accepted = inst.respond_to?(:cancel_async) ? inst.cancel_async : inst.kill
+              next unless accepted
+
+              requested[inst.id] = inst
+            end
+            break if targets.empty? || Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+            sleep 0.01
+          end
+
+          remaining = @monitor.synchronize do
+            (@instances.values + (@finished || {}).values + requested.values).uniq.select do |inst|
+              owned_by?(inst, token) && !cancellation_settled?(inst)
+            end
+          end
+          stopped = requested.values.reject { |inst| remaining.include?(inst) }.map(&:id)
+          CancellationOutcome.new(cancelled: true,
+                                  stopped: stopped.uniq,
+                                  remaining: remaining.map { |inst| { id: inst.id, state: inst.state.to_s } },
+                                  queued_cancelled: queued)
+        end
+
+        # A stopped execution is either disposed (the kill path completed) or
+        # settled naturally. Anything else is remaining work and must be named.
+        def cancellation_settled?(instance)
+          return instance.cancellation_settled? if instance.respond_to?(:cancellation_settled?)
+          return true if instance.respond_to?(:disposed?) && instance.disposed?
+
+          instance.terminal_and_settled?
+        end
+
+        def owned_by?(instance, token)
+          instance.respond_to?(:owner_task) && instance.owner_task.equal?(token)
+        end
+
+        # Claim fence: a pending spec whose owner was cancelled never starts.
+        # Called under the supervisor monitor by the dependency claim loops.
+        def owned_claim_blocked?(spec)
+          spec.respond_to?(:owner) && spec.owner&.cancelled?
+        end
+
+        # Guard for new owned work: refuse before anything is reserved.
+        def refute_cancelled_owner!(token)
+          return unless token&.cancelled?
+
+          raise TaskCancelledError,
+                "task was cancelled (^C) — new owned work is refused; pass detach: true to run it independently of this task"
+        end
+
+        private
+
+        # Cancel queued specs owned by the token and report their ids (the
+        # dependency wave that follows is announced by the same helper the
+        # dead-predecessor path uses).
+        def cancel_queued_specs(token)
+          queued = @monitor.synchronize do
+            specs = @deferred.values.select { |spec| spec.respond_to?(:owner) && spec.owner.equal?(token) }
+            specs.each { |spec| cancel_spec!(spec, "owner task cancelled (^C)") }
+            specs
+          end
+          announce_cancellations(queued)
+          queued.map(&:id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "notices"
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      # Instance teardown choreography, extracted from instance.rb (module
+      # hygiene; issue #125 added the cancellation notice and the
+      # operator-cancelled flag here): kill request (one terminal outcome per
+      # execution, thread kill), idempotent cleanup, and the monitor-guarded
+      # context disposal. Disposal itself stays LIFO + error-isolated inside
+      # Runtime::Context; cleanup_context only guarantees it runs exactly once.
+      module Teardown
+        # True when an OPERATOR kill (not a natural settle) stopped this
+        # execution. The completion handler reads it to suppress its own
+        # settle notice, so one execution never produces two terminal
+        # outcomes (issue #125).
+        def cancelled_by_operator? = @monitor.synchronize { @cancelled_by_operator }
+
+        # Foreground cancellation lets the existing worker drain its context.
+        # Repeated requests must not interrupt an inverse already unwinding.
+        def cancel_async
+          return true if @cancelled_by_operator
+
+          kill(cleanup: false, wait_for_lock: false)
+        end
+
+        # A cleanup inverse may hold the instance monitor. Deadline checks
+        # must report it as pending rather than blocking on that same monitor.
+        def cancellation_settled?
+          return false unless @monitor.try_enter
+
+          begin
+            disposed? || terminal_and_settled?
+          ensure
+            @monitor.exit
+          end
+        end
+
+        def kill(cleanup: true, wait_for_lock: true)
+          announce = false
+          if wait_for_lock
+            @monitor.enter
+          else
+            return false unless @monitor.try_enter
+          end
+          begin
+            return true if disposed?
+
+            announce = !settled? && !@cancelled_by_operator
+            @cancelled_by_operator ||= announce
+            transition!(:canceling)
+            @ended_at = Time.now
+            @budget_cond.broadcast
+            @error_cond.broadcast
+          ensure
+            @monitor.exit
+          end
+
+          # The cancellation announcement belongs to the kill path (the
+          # operator act), not to the completion choreography: it is emitted
+          # exactly once, and only when the run had not already settled.
+          if announce
+            Notices.emit(@event_bus, Notices::COMPLETED_EVENT,
+                         { id: @id, role: @role, state: :cancelled, max_steps: @budget.max_steps })
+          end
+          @journal&.record_cancelled(run: @run_seq, reason: "kill requested by maestro")
+
+          begin; @thread&.kill if @thread&.alive?; rescue StandardError; nil; end
+
+          self.cleanup if cleanup || !@thread&.alive?
+          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}"
+            end
+          end
+        end
+      end
+    end
+  end
+end