rubik 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bced6a0406961cf92cb6e9bcba59607c5517e4a14a205fca253d07cb461b6391
-  data.tar.gz: 2b1812eecdf480852cbaaae6d3ef507de561b10e0f628e87e7c831969db8dbd2
+  metadata.gz: f281eb015bdfadb67a18d2a61972c2559f448a0458915393443a39c042b8a1d9
+  data.tar.gz: dedd94f98ab0785e0688e256b8be35244d764c88ccbe87c9367836715c3c788d
 SHA512:
-  metadata.gz: e084f7f8f448a21537c39f0b96b2ef218ad02c7f1699aaf6da07318c1049a224d893595a90109dadc6838cfa2db92fd70302f9374065dd1cb869d12ee7441425
-  data.tar.gz: 7b19fb4c8ff589ffc386f65fe83d01117132c600e7fd316fc990d3047cb7eeb8f6d7c4a6f5498857d1a185d4be43ac41f4e47d6b8530c31c5fb24dec908e2c12
+  metadata.gz: bcaf73fa4a12d8084af7b7e8ae5f1886e14c0f55f7e8817112addc073d17533fce0bc0959971fc18654d217efb24cadd0cdb4fa128c9c6980f49c0ff7c3255d3
+  data.tar.gz: 7d5dfa25a399e9e2710d9cbd16ec7c5cb0cbc7b373c62dfd9b3eae76bc4505df08f1bb51f9d893715ca4045da61b9b25c0b8b9c835c4960549788a98fb256f0b

data/ATTRIBUTION.md

@@ -121,7 +121,7 @@ SOFTWARE.
 | **`strings-ansi`** | Piotr Murach | MIT | ANSI-aware string truncation and alignment for REPL formatters. |
 | **`reline`** | Hiroshi SHIBATA & Ruby Team | Ruby License / BSD-2-Clause | Line-editing, history navigation, autocompletion hooks, and headless terminal adaptation. |
 | **`prism`** | Kevin Newton & Ruby Core Team | MIT | High-performance Ruby parsing and AST extraction ([`Rubik::AST::RubyExtractor`](lib/rubik/ast/ruby_extractor.rb)). |
-| **`minitest`** | Ryan Davis & seattlerb | MIT | Fast, modular test suite powering Rubik's 3,500+ unit, integration, and contract tests. |
+| **`minitest`** | Ryan Davis & seattlerb | MIT | Fast, modular test suite powering Rubik's 3,600+ unit, integration, and contract tests. |
 | **`rubocop`** | Bozhidar Batsov & contributors | MIT | Static code analysis, style enforcement, and architectural hygiene gates. |
 | **`benchmark`, `logger`, `pstore`, `reline`, `fiddle`** | Ruby core / rubygems teams | Ruby License / BSD-2-Clause | Ruby stdlib gems pinned explicitly in `rubik.gemspec` as they are unbundled from the default set in Ruby 3.4/3.5. |
 

data/CHANGELOG.md

@@ -10,6 +10,48 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 Nothing yet.
 
+## [0.1.6] - 2026-10-15
+
+The execution-contract release: subagent runs become first-class,
+inspectable objects — retained results, one canonical transcript, an
+append-only journal, cancellable task trees — and the REPL learns to
+hand a just-entered prompt back for editing instead of firing it.
+
+### Added
+
+- **Execution contracts and task supervision (#136):** completed
+  subagent results are retained with paginated retrieval instead of
+  truncated previews; live and persisted transcript reads collapse
+  into one canonical reader with snapshot tokens; an append-only
+  execution journal records each step (redacted before clipping);
+  foreground cancellation propagates through owned descendants while
+  detached tokens stay uncancellable; the runtime reports current
+  operations with actionable wait states; and command exit codes plus
+  metadata survive both dispatch paths. Closes #122–#127 and #129.
+- **Esc returns pending prompts to editing (#141):** a configurable
+  admission window (`ui.prompt_grace_window_ms`, default 1000, 0 to
+  disable) lets Esc hand the complete prompt back to Reline before
+  any task, model call or turn recording starts; Ctrl+C cancels the
+  pending submission, reactive wake-ups cannot inject Enter into the
+  restored editor, and bang/exit commands plus programmatic input
+  keep direct execution.
+
+### Changed
+
+- **Redactor skips irrelevant static passes, keeps replacement order
+  (#142):** a precompiled union regex skips the eight static
+  credential passes when the input holds only assignments or URL
+  credentials, and the original replacement order is preserved —
+  masking a preceding token in one combined pass can create the word
+  boundary that exposes an adjacent bearer credential (regression
+  tested over 10,000 differential cases).
+- **Truncator fast path ~62% (#138):** `Truncator.truncate`
+  short-circuits untruncated texts with zero line allocations, and
+  custom truncator separators are preserved.
+- **Fuzzy matcher prunes window evaluations (#140):**
+  `find_closest_subsequence` pre-computes target line membership and
+  a prefix-sum upper bound before running LCS calls.
+
 ## [0.1.5] - 2026-10-13
 
 A dependency-floor release: the reactive wakeup contract moves into

data/lib/rubik/coeffects.rb

@@ -50,28 +50,27 @@ module Rubik
     # Storage::Service at shell boot and resolved by the storage tool /
     # read_file rubik://storage routes / supervisor transcript indexing.
     STORAGE_STORE  = "storage_store"
-    # The ask-maestro bridge (Subagent::Instance mixing in Questioner):
-    # supervisor#spawn provides each instance into its own child context so
-    # the subagent-plane ask_question resolves it at execute time; unsatisfied
-    # on the root context, where the tool keeps its human-dialog plane.
+    # The ask-maestro bridge (Subagent::Instance's Questioner): provided into
+    # each instance's child ctx so ask_question resolves it, never on the root.
     SUBAGENT_QUESTION_ASKER = "subagent_question_asker"
-    # The send_message attribution bridge: supervisor#spawn (and redeploy)
-    # provide each subagent's conversation id into its own child context so
-    # a subagent-plane message routes to the maestro under its REAL sender
-    # id; unsatisfied on the root context, where Supervisor#send_message
-    # keeps its machine default sender ("agent-0").
+    # The send_message attribution bridge: provided into each subagent's child
+    # ctx so a message routes to the maestro under its REAL sender id
+    # (unsatisfied on the root: Supervisor#send_message keeps "agent-0").
     SUBAGENT_SENDER_ID = "subagent_sender_id"
-    # The Vakanüvis chronicler harness (Storage::Vakanuvis::Harness),
-    # provided by Vakanuvis::Service at shell boot (Phase 4) and resolved
-    # by the vakanuvis tool (recall/record/forget/digest). Unsatisfied when
-    # the chronicler is disabled — the tool hides from the model surface.
+    # The Vakanüvis chronicler harness (Storage::Vakanuvis::Harness), provided
+    # by Vakanuvis::Service at boot and resolved by the vakanuvis tool;
+    # unsatisfied when the chronicler is disabled (the tool hides).
     VAKANUIS = "vakanuvis"
     # The ROOT conversation-window pruner harness (REPL::Pruner::Harness),
     # provided by Pruner::Service at shell boot (Phase 4; default ON via
     # subagents.pruner.enabled — opt-out: false) and resolved by the
-    # prune_context tool and the !prune command. Unsatisfied when the
-    # pruner is disabled.
+    # prune_context tool and the !prune command. Unsatisfied when
+    # the pruner is disabled.
     PRUNER = "pruner"
+    # Foreground task cancellation token (Orchestrator::TaskCancellation, #125):
+    # provided per turn and inherited by spawned subagent contexts — spawn tools
+    # resolve the OWNING task; detached subtrees carry a never-cancelled token.
+    TASK_CANCELLATION = "task_cancellation"
 
     # Read-side bridge: third-party providers may still register services
     # under these legacy alias keys; canonical keys are always tried first.

data/lib/rubik/config/defaults.rb

@@ -118,6 +118,7 @@ module Rubik
           "statusline_template" => "{model} · ctx {ctx} · {dirty} · sandbox {sandbox}",
           "input_box" => false,
           "paste_join_window_ms" => 120, # Plan 91: lines arriving within this gap join into one paste turn
+          "prompt_grace_window_ms" => 1000,
           "quiet_notices" => false # Plan 105: buffer background notices to inbox until prompt/enter
         },
         "workspace" => {
@@ -148,13 +149,15 @@ module Rubik
           "network_backoff_base" => 0.5,
           "error_wait_timeout" => 300,
           "question_timeout" => 300,
-          # Bitmiş subagent bu grace (sn) sonrasında reap edilir (0 = kapalı);
-          # tombstone_limit sorgulanabilir mezar taşı sayısını sınırlar:
+          # reap_finished_after: grace (sn, 0 = kapalı); tombstone_limit: sorgulanabilir mezar taşı sınırı.
           "reap_finished_after" => 300,
           "tombstone_limit" => 25,
-          # Maestro kapısı: maestro write_file/replace_file_content/run_command/
-          # run_tests araçlarını doğrudan ÇALIŞTIRAMAZ — subagent'a devir zorunlu
-          # (false = doktrin yalnız prompt düzeyinde, kapı kapalı):
+          "cancel_timeout" => 2, # foreground ^C: owned descendants' grace period (s) before force-kill
+          # Sonuç arşivi (issue #122): tamamlanan koşular oturum-içi saklanır; redeploy öncekini EZMEZ.
+          "result_archive" => { "ttl_seconds" => 3600, "max_runs_per_instance" => 8, "page_chars" => 4000 },
+          # Append-only execution journal (issue #124): per-execution JSONL, capped per file.
+          "journal" => { "max_bytes" => 2_097_152 },
+          # Maestro kapısı: maestro write_file/replace_file_content/run_command/run_tests'ı ÇALIŞTIRAMAZ:
           "maestro_gate" => true,
           "auto_pause_on_network_error" => true,
           "reactive_wakeup" => true,
@@ -217,6 +220,7 @@ module Rubik
 
         config.each do |key, val|
           current_key = prefix.empty? ? key.to_s : "#{prefix}.#{key}"
+          validate_prompt_grace_value!(current_key, val)
           if schema.is_a?(Hash) && !schema.key?(key.to_s)
             candidate_keys = schema.keys
             candidates = if defined?(Rubik::Tools::FuzzyMatcher)
@@ -235,7 +239,6 @@ module Rubik
             raise ArgumentError, suggestion_msg if strict
 
             @warnings << suggestion_msg
-
           elsif val.is_a?(Hash) && schema.is_a?(Hash) && schema[key.to_s].is_a?(Hash) && !schema[key.to_s].empty?
             validate_schema(val, schema[key.to_s], current_key, strict: strict)
           end

data/lib/rubik/config.rb

@@ -68,6 +68,8 @@ module Rubik
     def set(key, value, persist: nil)
       old_val = fetch(key)
       typed_val = parse_scalar_value(value)
+      validate_prompt_grace_value!(key.to_s, typed_val)
+      validate_schema(typed_val, DEFAULT_CONFIG["ui"], "ui") if key.to_s == "ui" && typed_val.is_a?(Hash)
       keys = key.to_s.split(".")
       last_key = keys.pop
       target = keys.reduce(@data) do |acc, k|
@@ -161,6 +163,12 @@ module Rubik
 
     private
 
+    def validate_prompt_grace_value!(key, value)
+      return unless key == "ui.prompt_grace_window_ms" && !(value.is_a?(Integer) && value >= 0)
+
+      raise ArgumentError, "ui.prompt_grace_window_ms must be a non-negative integer (milliseconds)"
+    end
+
     # save! returns itself for no-write scopes; persist outcomes are hashes.
     def persist_result(res)
       res.is_a?(Hash) ? res : { ok: true }

data/lib/rubik/orchestrator/step_executor.rb

@@ -151,7 +151,11 @@ module Rubik
               error: err,
               output: trunc_res[:text],
               duration_ms: dur,
-              truncated: trunc_res[:truncated]
+              truncated: trunc_res[:truncated],
+              # Structured fields ride along when the tool provides them
+              # (issue #127): the same Result contract for every carrier.
+              exit_code: raw_output.respond_to?(:exit_code) ? raw_output.exit_code : nil,
+              metadata: raw_output.respond_to?(:metadata) ? raw_output.metadata : {}
             )
           else
             out_str = raw_output.to_s
@@ -239,6 +243,8 @@ module Rubik
           step: @deps.step_count,
           max_steps: @deps.max_steps,
           call_id: call_id,
+          exit_code: tool_result.exit_code,
+          metadata: tool_result.metadata,
           line_count: tool_result.output.to_s.lines.size,
           byte_size: tool_result.output.to_s.bytesize,
           tokens: @deps.total_tokens
@@ -246,7 +252,8 @@ module Rubik
 
         Rubik::Orchestrator::ToolHistory.write(@deps.history, tool_call_id: call_id, tool_name: tool_name,
                                                               status: tool_result.status, duration_ms: tool_result.duration_ms,
-                                                              content: tool_result.to_xml)
+                                                              content: tool_result.to_xml, exit_code: tool_result.exit_code,
+                                                              metadata: tool_result.metadata)
         @deps.activity.record(tool_name, tool_args, tool_result.status) if @deps.respond_to?(:activity)
         @deps.reset_invalid_tools!
         tool_result

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../task_cancellation"
+
 module Rubik
   module Orchestrator
     module Subagent
@@ -23,13 +25,18 @@ module Rubik
         # happens at execute time, but a start_async completion must never
         # race an unprovided asker), unit registration second (pre-start, so
         # the kernel board sees a live unit), start_async last.
-        def activate_instance!(inst, child_ctx:)
+        def activate_instance!(inst, child_ctx:, owner_token: nil)
           # ask_question'ın subagent düzlemi: instance kendi child ctx'ine
           # asker olarak publish edilir.
           child_ctx&.provide(Rubik::Coeffects::SUBAGENT_QUESTION_ASKER, inst)
           # send_message atfı: subagent→maestro mesajları gerçek gönderen
           # id'siyle taşır (coeffect yoksa root default'u yanlış atfı yapar).
           child_ctx&.provide(Rubik::Coeffects::SUBAGENT_SENDER_ID, inst.id)
+          # Task ownership (issue #125): the spawned execution (and, through
+          # inheritance, its own nested spawns) carries the owner's token; a
+          # detached spawn gets a never-cancelled token so its whole subtree
+          # survives a foreground ^C.
+          child_ctx&.provide(Rubik::Coeffects::TASK_CANCELLATION, owner_token || TaskCancellation.detached)
           eff_init = @init || (@root_context.respond_to?(:get) && Rubik::Coeffects.get(@root_context, Rubik::Coeffects::INIT))
           eff_init&.register(Kernel::SubagentUnit.new(inst, context: child_ctx, birth_state: unit_birth_state(inst)))
           inst.start_async { |completed_inst| handle_subagent_completion(completed_inst) }

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

@@ -16,18 +16,45 @@ module Rubik
         def handle_subagent_completion(inst)
           merge_branch_buffer(inst) if inst.workspace == "branch" && inst.completed?
           auto_apply_subagent_buffer(inst) if inst.completed?
+          retain_result(inst)
           Rubik::Storage::TranscriptIndexer.index(storage_store, inst)
           reap_orphans
           release_ready!
-          # Result is deliberately absent: notices announce, the model retrieves
-          # via manage_subagents wait — the wait protocol stays authoritative.
+          emit_completion_notice(inst)
+        end
+
+        private
+
+        # One terminal outcome per execution (issue #125): an operator kill
+        # already announced the cancellation from the kill path — the settle
+        # notice would be a duplicate. Natural settles announce here, with the
+        # canonical result reference so a truncated preview keeps a working
+        # continuation (result_ref, issue #122).
+        def emit_completion_notice(inst)
+          return if inst.respond_to?(:cancelled_by_operator?) && inst.cancelled_by_operator?
+
           # max_steps rides along so the budget-exhausted guidance can count.
           # storage_id: Vakanüvis kronikçisinin annal/transcript ref anahtarı
           # (plan 2026-10-04) — mevcut aboneler bu anahtarı yok sayar.
-          Notices.emit(@event_bus, Notices::COMPLETED_EVENT, { id: inst.id, role: inst.role, state: inst.state, max_steps: inst.max_steps, storage_id: inst.storage_id })
+          Notices.emit(@event_bus, Notices::COMPLETED_EVENT,
+                       { id: inst.id, role: inst.role, state: inst.state, max_steps: inst.max_steps,
+                         storage_id: inst.storage_id, result_ref: (inst.result_ref if inst.settled?),
+                         transcript_ref: inst.transcript_ref })
         end
 
-        private
+        # The result archive's single write site (issue #122): a settled run
+        # retains its redacted result under its execution-specific reference
+        # (storage id + run sequence) so retrieval never needs a redeploy.
+        # A retention failure degrades to a warning — the durable transcript
+        # remains the fallback, and completion choreography must not stall.
+        def retain_result(inst)
+          return unless inst.settled? && @result_archive
+
+          @result_archive.retain(storage_id: inst.storage_id, id: inst.id, run: inst.run_seq,
+                                 state: inst.state, body: inst.result)
+        rescue StandardError => e
+          Rubik::Log.warn(:orchestrator, "result archive retain failed for #{inst.id}: #{e.class}: #{e.message}")
+        end
 
         # Completion-time spelling of the shared auto-apply policy: the
         # subagents flag OR the buffer.auto_apply mode decides (previously

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "notices"
+require_relative "../provider_recovery"
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      # The subagent's context-recovery plane, extracted from StepRunner
+      # (module hygiene): routine compaction evaluation, the emergency
+      # compaction actuator, and the bus announcement. One vertical slice —
+      # history pruning and its observable event.
+      module ContextCompaction
+        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
+          )
+          before = @history.size
+          @history.replace(compacted)
+          # Journaled BEFORE the next step can prune further (issue #124): the
+          # pre-compaction event sequence stays reconstructible.
+          @journal&.record_compaction(run: @run_seq, layer: "context_compactor", before: before, after: @history.size)
+        end
+
+        # Compaction actuator for the subagent path (mirrors Loop's seam): the
+        # body lives in TurnExecutor#emergency_compact! (one home for both
+        # channels); this delegates and the channel announces on the bus. 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)
+          @journal&.record_compaction(run: @run_seq, layer: layer, reason: reason)
+          Notices.emit(@event_bus, Notices::COMPACTED_EVENT, { id: @id, role: @role, state: @state, reason: reason.to_s, layer: layer })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "budget"
+require_relative "notices"
+require_relative "conversation_id"
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      # A dependency-queued spawn specification (PM-style dispatch constraints,
+      # user decision 2026-10-01): a linked task does not fire concurrently —
+      # FS (finish-to-start, default) launches when the predecessor completes,
+      # SS (start-to-start) when it first turns running. A queued spec is NOT
+      # an Instance: no thread, no slot, no cost — the real spawn choreography
+      # runs only when it is released. FF/SF are deliberately unsupported v1
+      # (normalize_dep rejects them).
+      #
+      # `owner` (issue #125): the cancellation token of the task that requested
+      # this spec — nil for explicitly detached work. A cancelled owner makes
+      # the claim loops drop the spec before it ever starts.
+      class DeferredSpec
+        attr_reader :id, :parent_id, :role, :type_name, :prompt, :system_prompt,
+                    :workspace, :model, :max_steps, :deps, :provider, :owner
+        attr_accessor :state, :cancel_reason
+
+        def initialize(id:, role:, prompt:, type_name:, deps:, parent_id: ConversationId::ROOT_ID, system_prompt: nil,
+                       workspace: "inherit", model: "inherit", max_steps: nil, provider: nil, owner: nil)
+          @id = id
+          @parent_id = parent_id
+          @role = role
+          @prompt = prompt
+          @type_name = type_name
+          @deps = deps
+          @system_prompt = system_prompt
+          @workspace = workspace
+          @model = model
+          @max_steps = max_steps
+          @provider = provider
+          @owner = owner
+          @state = :queued
+          @cancel_reason = nil
+        end
+
+        def queued? = @state == :queued
+        def spawning? = @state == :spawning
+        def cancelled? = @state == :cancelled
+
+        # Duck-type yüzeyi: render'lar (list/status/wait) Instance ile
+        # DeferredSpec'i AYIRT ETMEDEN kullanır — dallanma yok.
+        def running? = false
+        def active? = false
+        def uptime = 0.0
+        def started_at = nil
+        def current_step = 0
+        def result = nil
+        def transcript_uri = nil
+        def last_error = @cancel_reason
+        def terminal_and_settled? = false
+        def redeployable? = false
+        # send_message'in deliverable? kapısı spec'e de değebilir (get,
+        # kuyruk fallback'i döndürür): bir spec henüz doğmadı — teslim
+        # edilemez.
+        def deliverable? = false
+
+        def depends_on = @deps.map { |d| "#{d[:id]}:#{d[:type]}" }
+
+        def to_h
+          { id: @id, parent_id: @parent_id, role: @role, type: @type_name, state: @state.to_s,
+            depends_on: depends_on, current_step: 0, max_steps: @max_steps, uptime_seconds: 0.0,
+            started_at: nil, ended_at: nil, transcript: nil, last_error: @cancel_reason,
+            result_summary: nil, result: nil, detached: @owner.nil? }
+        end
+      end
+    end
+  end
+end

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

@@ -3,69 +3,11 @@
 require_relative "budget"
 require_relative "notices"
 require_relative "conversation_id"
+require_relative "deferred_spec"
 
 module Rubik
   module Orchestrator
     module Subagent
-      # PM tarzı dispatch kısıtları (kullanıcı kararı 2026-10-01): bağlı
-      # işler aynı anda ateşlenmez — FS (finish-to-start, varsayılan) öncül
-      # tamamlanınca, SS (start-to-start) öncül İLK kez running'a geçince
-      # bırakılır. Bekleyen spec bir Instance DEĞİL: thread yok, slot yok,
-      # maliyet yok — bırakılınca gerçek spawn koreografisi oynar.
-      # FF/SF v1'de bilinçli olarak desteklenmez (normalize_dep reddeder).
-      class DeferredSpec
-        attr_reader :id, :parent_id, :role, :type_name, :prompt, :system_prompt,
-                    :workspace, :model, :max_steps, :deps, :provider
-        attr_accessor :state, :cancel_reason
-
-        def initialize(id:, role:, prompt:, type_name:, deps:, parent_id: ConversationId::ROOT_ID, system_prompt: nil,
-                       workspace: "inherit", model: "inherit", max_steps: nil, provider: nil)
-          @id = id
-          @parent_id = parent_id
-          @role = role
-          @prompt = prompt
-          @type_name = type_name
-          @deps = deps
-          @system_prompt = system_prompt
-          @workspace = workspace
-          @model = model
-          @max_steps = max_steps
-          @provider = provider
-          @state = :queued
-          @cancel_reason = nil
-        end
-
-        def queued? = @state == :queued
-        def spawning? = @state == :spawning
-        def cancelled? = @state == :cancelled
-
-        # Duck-type yüzeyi: render'lar (list/status/wait) Instance ile
-        # DeferredSpec'i AYIRT ETMEDEN kullanır — dallanma yok.
-        def running? = false
-        def active? = false
-        def uptime = 0.0
-        def started_at = nil
-        def current_step = 0
-        def result = nil
-        def transcript_uri = nil
-        def last_error = @cancel_reason
-        def terminal_and_settled? = false
-        def redeployable? = false
-        # send_message'in deliverable? kapısı spec'e de değebilir (get,
-        # kuyruk fallback'i döndürür): bir spec henüz doğmadı — teslim
-        # edilemez.
-        def deliverable? = false
-
-        def depends_on = @deps.map { |d| "#{d[:id]}:#{d[:type]}" }
-
-        def to_h
-          { id: @id, parent_id: @parent_id, role: @role, type: @type_name, state: @state.to_s,
-            depends_on: depends_on, current_step: 0, max_steps: @max_steps, uptime_seconds: 0.0,
-            started_at: nil, ended_at: nil, transcript: nil, last_error: @cancel_reason,
-            result_summary: nil, result: nil }
-        end
-      end
-
       # Saf graf fonksiyonları — kilit yok, IO yok, izole test edilebilir.
       module DependencyGraph
         module_function
@@ -130,12 +72,16 @@ module Rubik
         # doğrula (döngü/ölü öncül/bilinmeyen referans => ArgumentError,
         # HİÇBİR ŞEY rezerve edilmeden), sonra rezerve et ve hazır olanları
         # talep et. Dönen çiftler: [:launched, Instance] | [:queued, DeferredSpec].
-        def spawn_batch(specs)
+        # `owner` (issue #125): çağıranın görev iptal token'ı — spec'e miras
+        # kalır; iptal edilmiş sahiple yeni iş RESERVE EDİLMEZ.
+        def spawn_batch(specs, owner: nil)
           reserved = []
           claimed = []
+          cancelled = []
           @monitor.synchronize do
             base = @counter
-            normalized = specs.each_with_index.map { |s, i| normalize_batch_spec(s, base + i + 1) }
+            normalized = specs.each_with_index.map { |s, i| normalize_batch_spec(s, base + i + 1, owner) }
+            normalized.each { |spec| refute_cancelled_owner!(spec.owner) }
             refute_dead_dependencies!(normalized)
             refute_unknown_dependencies!(normalized)
             DependencyGraph.assert_acyclic!(dependency_graph(normalized))
@@ -145,12 +91,20 @@ module Rubik
             end
             @counter += normalized.size
             reserved.each do |spec|
+              # Claim fence: cancellation may land between the entry guard and
+              # this loop — a cancelled owner never launches.
+              if owned_claim_blocked?(spec)
+                cancel_spec!(spec, "owner task cancelled (^C)")
+                cancelled << spec
+                next
+              end
               next unless dependencies_evaluate(spec) == :ready
 
               spec.state = :spawning
               claimed << spec
             end
           end
+          announce_cancellations(cancelled)
 
           reserved.map do |spec|
             claimed.include?(spec) ? launch_claimed!(spec) : resolve_outcome(spec)
@@ -171,6 +125,16 @@ module Rubik
               @deferred.each_value do |spec|
                 next unless spec.queued?
 
+                # Ownership fence (issue #125): a spec whose task was cancelled
+                # is dropped here — it never starts, and its dependents cascade
+                # to death through the same fixed-point wave as a dead
+                # predecessor.
+                if owned_claim_blocked?(spec)
+                  cancel_spec!(spec, "owner task cancelled (^C)")
+                  wave << spec
+                  next
+                end
+
                 case dependencies_evaluate(spec)
                 when :ready
                   spec.state = :spawning
@@ -254,7 +218,7 @@ module Rubik
           inst = spawn(role: spec.role, prompt: spec.prompt, type_name: spec.type_name,
                        system_prompt: spec.system_prompt, parent_id: spec.parent_id,
                        workspace: spec.workspace, model: spec.model, max_steps: spec.max_steps,
-                       provider: spec.provider, reserved_id: spec.id)
+                       provider: spec.provider, reserved_id: spec.id, owner: spec.owner)
 
           killed_midflight = false
           @monitor.synchronize do
@@ -309,7 +273,7 @@ module Rubik
           end
         end
 
-        def normalize_batch_spec(raw, provisional_id)
+        def normalize_batch_spec(raw, provisional_id, owner = nil)
           role = raw[:role].to_s.strip
           prompt = raw[:prompt].to_s.strip
           raise ArgumentError, "Subagent role cannot be empty" if role.empty?
@@ -320,7 +284,8 @@ module Rubik
             type_name: (raw[:type_name] || "research").to_s.strip, deps: DependencyGraph.normalize_deps(raw[:depends_on]),
             system_prompt: raw[:system_prompt], workspace: (raw[:workspace] || "inherit").to_s,
             model: (raw[:model] || "inherit").to_s, max_steps: (raw[:max_steps] || @default_max_steps).to_i,
-            provider: raw[:provider], parent_id: (raw[:parent_id] || ConversationId::ROOT_ID).to_s
+            provider: raw[:provider], parent_id: (raw[:parent_id] || ConversationId::ROOT_ID).to_s,
+            owner: raw[:detach] ? nil : owner
           )
         end
 

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "transcript_reader"
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      # Execution-keyed read seams (issues #122/#123): resolve an execution by
+      # its unique storage id and serve its canonical transcript pages. Kept
+      # out of supervisor.rb to stay under the module-hygiene cap; the
+      # supervisor includes it and owns the state these methods read.
+      module ExecutionReads
+        # Tombstones included: a reaped execution stays addressable within
+        # retention. Display ids restart every process — storage ids are the
+        # durable address, so lookup keys on storage_id, never on the id.
+        def find_by_storage_id(storage_id)
+          sid = storage_id.to_s
+          return nil if sid.empty?
+
+          @monitor.synchronize do
+            (@instances.values + (@finished || {}).values).find do |inst|
+              inst.respond_to?(:storage_id) && inst.storage_id.to_s == sid
+            end
+          end
+        end
+
+        # Was this execution ever known to the runtime? Distinguishes an
+        # expired (reaped + transcript gone) address from an unknown one; the
+        # result archive keeps the last bounded proof after tombstone eviction.
+        def execution_tracked?(storage_id)
+          sid = storage_id.to_s
+          return true if find_by_storage_id(sid)
+
+          @result_archive.respond_to?(:known?) && @result_archive.known?(sid)
+        end
+
+        # The canonical transcript read seam (issue #123): the supervisor owns
+        # both planes (roster + root/storage resolution), so one call serves
+        # live memory or the persisted snapshot with snapshot-stable pages.
+        def read_transcript(storage_id, cursor: 0, limit: nil, snapshot: nil)
+          sid = storage_id.to_s
+          Rubik::Orchestrator::Subagent::TranscriptReader.read(
+            storage_id: sid, instance: find_by_storage_id(sid), root_dir: @root_dir, storage: absorb_storage,
+            tracked: execution_tracked?(sid), cursor: cursor, limit: limit, snapshot: snapshot
+          )
+        end
+      end
+    end
+  end
+end