rubik 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a55adca9a39a813ea7620e63018dc98ae7c902142e9a1fa1dc5afe92637ef88
-  data.tar.gz: 72d7ca21a839051017fd515fe63a0cc99573054ec3a23c5fd179a6e37c623460
+  metadata.gz: cd6a93a2277eebd80ce20dbf33ceba1ba7354d6540a6906740b4d58274736847
+  data.tar.gz: 2f46b92bbf23cbcea71767c433ffd45dd55b821e6bb8f1b18cb8c2e7310c5be0
 SHA512:
-  metadata.gz: f4b426b159392a724d6e66d96dfd09db13cee8882eec7f3dcf0afaaf3d683325d3a74731f0e34abf43e77c1f1655d850cecd2912e324e16da9ad84bd74c1eb71
-  data.tar.gz: 36090da4466990229e789cf5912cf880bf4193eb300f8823abc7a1cefed4bf6253aff44774ff9d18e19ebbfb3f874d7c70434d7ab72692ba474bd9e6ba337abf
+  metadata.gz: 258d3631c684bfdd719a3b341197dd02da8fc64789c30645b8df0cd4814fc7546392c371737582adab36ff4d46052828fe8d0fed536a1efb592b2c5dcca34571
+  data.tar.gz: d9a517f0f4b7026d666d3ac0e2f880805ce40d2341613e5cc75ed72b5b37df3eabf60f07cee9cdf2d8a491b3758b0871edc43b62e501b423bde817b814b1edaf

data/CHANGELOG.md

@@ -6,6 +6,82 @@ commits, 2026-08-23 → 2026-10-09, see `git log`).
 
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.6.0] - 2026-11-02
+
+A measurement-and-honesty minor: the planned vakanüvis fixes gain their
+baseline with a tool-adoption bench scenario, goal suspensions finally
+reach the chronicle through a typed digest contract, interleaved-goal
+suspend rows stop mispairing their records, the annal dedupe can no
+longer be poisoned by free-text `event=` markers, and a typo'd
+truncation strategy warns instead of silently no-oping.
+
+### Added
+
+- **Goal suspension chronicling:** the chronicler now subscribes to
+  `:goal_suspended` (previously posted by `GoalState` but bus-orphaned —
+  the producer comment promised a consumption that never existed) and
+  appends a `goal.<n>.suspended` row to the session annal; the ordinal is
+  peeked rather than minted, so the eventual finish shares the same
+  `goal.<n>` record and no duplicate goal note is born from a suspension.
+- **vakanüvis tool-adoption bench scenario (#338, #354):** a two-plane
+  measurement of whether models actually adopt recall/record — a
+  deterministic replay (default, runs in `rake bench` and CI) driving the
+  real tool plane through adopter/wrong-path/struggler profiles, and an
+  opt-in live plane (`rake bench:vakanuvis_adoption MODELS=...`) looping
+  real provider completions with both tools available; per-model metrics
+  cover recall adoption, Keywords usage, record-via-vakanüvis vs direct
+  storage put, answer grounding and turn-cap hits, with honest Skip
+  (quota) vs Error rows and a fresh seeded store per driver.
+  `:goal_suspended` (previously posted by `GoalState` but bus-orphaned —
+  the producer comment promised a consumption that never existed) and
+  appends a `goal.<n>.suspended` row to the session annal; the ordinal is
+  peeked rather than minted, so the eventual finish shares the same
+  `goal.<n>` record and no duplicate goal note is born from a suspension.
+
+### Changed
+
+- **Digest contract typed:** the digest job is one `DistillGate::Job`
+  Struct (the queue's two Hash literals collapse into a keyword-minted
+  shape), the orphaned `:goal_id` read that no site ever set becomes a
+  live `goal_ordinal` carried from goal-end auto-digest — the distiller
+  brief now cites the goal record for goal-tied digests — and the digest
+  receipt text is single-homed in the DistillGate rules module
+  (`receipt` / `duplicate_receipt` / `full_receipt`) instead of three
+  templates across two files.
+- **Truncation strategy parity:** `tools.truncation_strategy` was honored
+  by exactly one of the Truncator call sites while the subagent tool
+  dispatch hard-coded `head_tail` under a comment claiming the two planes
+  cannot drift; both orchestrator planes now fetch the knob (fallback
+  `Truncator::DEFAULT_STRATEGY`), the restated 12_000/300 literals resolve
+  from `Truncator::DEFAULT_MAX_CHARS/LINES`, and a parity pin test turns
+  the prose invariant into a test invariant (classification, truncation
+  and the strategy knob are asserted equal across the two planes, oracle-
+  anchored against Truncator directly). The configuration docs now name
+  the honoring consumers.
+
+### Fixed
+
+- **Goal-identity suspend keys and honest logs (#350, #351):** suspend
+  rows key on goal identity (ledger id, else slug) plus steps and an
+  error digest instead of a peeked ordinal — interleaved goals no longer
+  mispair A's suspend row to B's finish and two suspensions sharing a
+  peek no longer dedupe into one row; `AnnalWriter.event_context` adds
+  status + goal so a dropped suspension and a dropped finish are
+  distinguishable in the logs; a `:duplicate` auto-digest admission warns
+  with the topic and unattached ordinal instead of silently succeeding;
+  the append dedupe anchors on line ends so free-text fields carrying
+  `(event=...)` cannot plant phantom keys that suppress genuine rows; the
+  chronicler worker gains a per-iteration last-ditch rescue with a
+  backtrace frame, the ledger id is stamped before `suspend!`, and a
+  spawn-disabled flush warns honestly instead of queueing in silence.
+- **Unrecognized truncation strategy values warn once (#349):** a typo'd
+  `tools.truncation_strategy` (or `context.emergency_truncate_strategy`)
+  previously fell into the `head_tail` else branch with no signal in
+  either plane; `Truncator::STRATEGIES` is now the honest frontier, all
+  three config-fetch sites resolve through it, and each distinct unknown
+  value warns exactly once per knob+value pair with a UTF-8-scrubbed
+  message that can never turn tool results into errors.
+
 ## [0.5.0] - 2026-10-31
 
 A vakanüvis minor: the memory system gains a harness-owned auto-digest
@@ -1007,7 +1083,8 @@ installation section.
 - Context: serialized index mutations, snapshot-outside-lock reconcile,
   streaming-first truncation.
 
-[Unreleased]: https://github.com/ozgurulukir/rubik/compare/v0.5.0...HEAD
+[Unreleased]: https://github.com/ozgurulukir/rubik/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/ozgurulukir/rubik/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/ozgurulukir/rubik/compare/v0.4.2...v0.5.0
 [0.4.2]: https://github.com/ozgurulukir/rubik/compare/v0.4.1...v0.4.2
 [0.4.1]: https://github.com/ozgurulukir/rubik/compare/v0.4.0...v0.4.1

data/lib/rubik/benchmark/runner.rb

@@ -3,6 +3,8 @@
 require "benchmark"
 require "tmpdir"
 
+require_relative "vakanuvis_adoption"
+
 module Rubik
   module Benchmark
     class MetricResult
@@ -38,9 +40,21 @@ module Rubik
         results << bench_grep_tool
         results << bench_cold_scan
         results << bench_search_ranking
+        results.concat(bench_vakanuvis_adoption)
         results
       end
 
+      # issue #338: araç-benimseme taban çizgisi. Ana süit YALNIZ deterministik
+      # replay düzlemini koşar (canlı model çağrısı asla default olamaz);
+      # canlı ölçüm rake bench:vakanuvis_adoption MODELS=... ile açık istektir.
+      def bench_vakanuvis_adoption
+        rows = Rubik::Benchmark::VakanuvisAdoption.run(
+          Rubik::Benchmark::VakanuvisAdoption::REPLAY_PROFILES.map { |p| Rubik::Benchmark::VakanuvisAdoption::ReplayDriver.new(p) },
+          io: nil
+        )
+        Rubik::Benchmark::VakanuvisAdoption.metric_results(rows, io: nil)
+      end
+
       def generate_markdown_report(results)
         lines = []
         lines << "| Metric | Target | Measured | Status |"

data/lib/rubik/benchmark/vakanuvis_adoption.rb

@@ -0,0 +1,439 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "fileutils"
+require_relative "../storage/vakanuvis"
+require_relative "../tools/builtins/storage"
+require_relative "../tools/builtins/vakanuvis"
+
+module Rubik
+  module Benchmark
+    # Vakanüvis araç-benimseme senaryosu (issue #338): küçük modellerin
+    # vakanüvis'i ne sıklıkla, nasıl kullandığını ölçen taban çizgisi.
+    # "Bu düzeltme iğneyi hareket ettirdi mi?" sorusunun cevabı için
+    # prompt-doktrin / yönelim-enjeksiyonu / otomatik-damıtma düzeltmeleri
+    # ÖNCE bu ölçüm ister.
+    #
+    #   Düzlem 1 (deterministik, CI-güvenli): tohum depo + ReplayDriver —
+    #   üç davranış profili GERÇEK araç düzlemini çalıştırır (script'lenmiş
+    #   araç çağrıları, sahte sonuçlar değil); metrik borusu ve recall
+    #   çıktı biçimi regresyona girerse burada patlar.
+    #   Düzlem 2 (canlı): LiveDriver provider.complete döngüsü — MODELS
+    #   env'i ile model başına gerçek benimseme ölçümü.
+    #
+    # Sessizlik: canlı modeller maliyetli ve deterministik değildir — bu
+    # yüzden default Düzlem 1'dir; rake bench ana süitine asla canlı çağrı
+    # sızdırmaz (bench:vakanuvis_adoption MODELS=... açık istek ister).
+    module VakanuvisAdoption
+      # Tohum kartlar: TR/EN karışık, Keywords: satırlı/satırsız — issue
+      # senaryosunun ta kendisi. Görev-1 kartının ayırt edici değerleri
+      # (8 saniye adımı + 5 deneme) yanıt-kullanımını dürüstçe sayılabilir
+      # kılar: model hatırladığı karttan alıntıladıysa ikisi de görünür.
+      SEED_CARDS = [
+        {
+          topic: "Ağ geçidi yeniden deneme politikası",
+          body: "Ağ geçidi 429/503 yanıtında üstel geri çekilme uygular: 2s, 4s, 8s " \
+                "(en fazla 5 deneme). Devre kesici 30 ardışık hata sonra açılır.\n" \
+                "Keywords: gateway retry backoff üstel geri çekilme 429 503 circuit breaker exponent"
+        },
+        {
+          topic: "Sandbox filesystem allowlist",
+          body: "The container sandbox mounts the worktree read-write and $HOME read-only; " \
+                "the allowlist file is sandbox.allow at the repo root.\n" \
+                "Keywords: sandbox allowlist container readonly mount worktree izin listesi"
+        },
+        {
+          topic: "Vakanüvis damıtma kapısı",
+          body: "Damıtma kapısı aynı hedefli işi yutar (dedupe); maksimum kuyruk 8 iş, " \
+                "hedef başına tek iz."
+        },
+        {
+          topic: "Fiber scheduler budget",
+          body: "The fiber scheduler caps concurrent subagent fibers at 12; overflow " \
+                "queues FIFO and never drops."
+        },
+        {
+          topic: "Goal sıra türetimi",
+          body: "Goal sırası mağazadaki en büyük annal.goal.N'den türetilir; duvar saati " \
+                "ASLA kullanılmaz — kronik MARKER-ZIKKIM-7 determinizmi budur."
+        }
+      ].freeze
+
+      # Görev 1 yanıt izleri: karttan alıntı → ikisi de eşleşir; uydurma
+      # yanıt → en az biri (genelde ikisi) kaçar.
+      ANSWER_MARKER_BACKOFF = /8\s*(s\b|sn|sec|second|saniye)/i
+      ANSWER_MARKER_TRIES = /(5|beş|five)\s*(deneme|attempt|retr|try)/i
+
+      TASKS = [
+        {
+          id: "recall-tr-en",
+          prompt: "Bu sorunun cevabı rubik://storage kronikçisindeki bir hafıza kartında duruyor: " \
+                  "ağ geçidi (gateway) 429/503 yanıtında yeniden deneme / geri çekilme politikası nedir? " \
+                  "Kısa cevabını ver."
+        },
+        {
+          id: "durable-conclusion",
+          prompt: "We just concluded that the chronicler's digest gate deduplicates jobs for the " \
+                  "same target. Persist this durable conclusion so future sessions can recall it, " \
+                  "then confirm in one line."
+        }
+      ].freeze
+
+      MAX_TURNS = 8
+      REPLAY_PROFILES = ["adopter", "wrong-path", "struggler"].freeze
+
+      module_function
+
+      # ---- mağaza + araç masası ---------------------------------------------
+
+      # Kronikçi yapılandırması: damıtıcı KAPALI (bench'te asla LLM doğumu —
+      # ölçtüğümüz şey maestro davranışı, damıtıcı maliyeti değil).
+      class QuietConfig
+        def fetch(key, default = nil)
+          return false if key == "subagents.vakanuvis.distiller"
+
+          default
+        end
+      end
+
+      # Deterministik tohum: aynı kart dizisi ⇒ aynı mağaza ⇒ aynı recall
+      # davranışı. Her model/profil ÖZGÜN kök dizinle başlar (record
+      # yan etkileri bir sonraki modelin ölçümünü kirletmesin).
+      def seed_store(root)
+        store = Rubik::Storage::Store.new(root: root, project: "vakanuvis-adoption-bench")
+        harness = Rubik::Storage::Vakanuvis::Harness.new(store: store, config: QuietConfig.new, session_slug: "bench-seed")
+        SEED_CARDS.each { |card| harness.record(topic: card[:topic], body: card[:body]) }
+        harness.shutdown
+        store
+      end
+
+      # İki gerçek yerleşik araç: vakanüvis (doğru yol) + storage (yanlış
+      # yolun mümkün olması için masada DURMALI — yoksa yanlış-yol oranı
+      # ölçülemez, sahte sıfır doğardı).
+      class ToolBench
+        def initialize(store, harness)
+          @tools = {
+            "vakanuvis" => Rubik::Tools::VakanuvisTool.new(harness),
+            "storage" => Rubik::Tools::StorageTool.new(store)
+          }
+        end
+
+        def execute(name, args)
+          tool = @tools[name.to_s]
+          return "Unknown tool '#{name}' (bench toolbelt: vakanuvis, storage)." unless tool
+
+          tool.execute(args || {})
+        rescue StandardError => e
+          "tool error: #{e.class}: #{e.message}"
+        end
+
+        def schemas = @tools.values.map(&:to_h)
+      end
+
+      # ---- sürücüler --------------------------------------------------------
+      # Sözleşme: run_task(task, tools) -> { turns:, answer:, calls:,
+      # first_recall_turn:, hit_cap: }. calls = [[name, args, result_text]]
+      # (sıralı). first_recall_turn = ilk recall'in 1-tabanlı turn'ü.
+
+      # Script'lenmiş davranış profilleri — scriptler GERÇEK araçlarla
+      # koşar (sonuç sahtelenmez); metrik borusunun deterministik kanıtı.
+      class ReplayDriver
+        attr_reader :profile
+
+        def initialize(profile)
+          @profile = profile.to_s
+        end
+
+        def label = "scripted/#{@profile}"
+
+        def live? = false
+
+        def run_task(task, tools)
+          calls = []
+          answer = ""
+          turns = 0
+          first_recall_turn = nil
+          SCRIPTS.fetch(@profile).fetch(task[:id]).each do |step|
+            turns += 1
+            steps = step[:call] ? [step[:call]] : (step[:call_each] || [])
+            steps.each do |name, args|
+              first_recall_turn ||= turns if recall_step?(name, args)
+              calls << [name, args, tools.execute(name, args)]
+            end
+            answer = step[:answer] if step.key?(:answer)
+          end
+          { turns: turns, answer: answer, calls: calls, first_recall_turn: first_recall_turn, hit_cap: false }
+        end
+
+        private
+
+        def recall_step?(name, args)
+          name == "vakanuvis" && (args["action"].nil? || args["action"] == "recall")
+        end
+      end
+
+      # Canlı sürücü: provider.complete döngüsü. Prompt görevi söyletir,
+      # araç seçimini ASLA emretmez — benimseme ölçümünün koşulu budur.
+      class LiveDriver
+        def initialize(provider, max_turns: MAX_TURNS)
+          @provider = provider
+          @max_turns = max_turns
+        end
+
+        def label = "live/#{@provider.name}/#{@provider.model}"
+
+        def live? = true
+
+        def run_task(task, tools)
+          history = [{ "role" => "user", "content" => task[:prompt] }]
+          calls = []
+          turns = 0
+          first_recall_turn = nil
+          answer = ""
+
+          @max_turns.times do
+            turns += 1
+            res = @provider.complete(history, { tools: tools.schemas })
+            # Sağlayıcı sözleşmesi (inceleme turu 2): Response dışı bir
+            # dönüş, respond_to? zincirlerine girip sahte "araç
+            # benimsemedi / tur sınırına vurdu" veri noktası üretmesin —
+            # dürüstçe patla.
+            raise "provider returned #{res.inspect}, expected Rubik::LLM::Response" unless res.is_a?(Rubik::LLM::Response)
+
+            tool_calls = res.respond_to?(:tool_calls?) && res.tool_calls? ? res.tool_calls : []
+            if tool_calls.empty?
+              answer = res.respond_to?(:text) ? res.text.to_s : res.to_s
+              break
+            end
+
+            history << {
+              role: "assistant",
+              content: res.respond_to?(:text) ? res.text.to_s : "",
+              tool_calls: tool_calls.map { |tc| { "id" => tc["id"], "tool" => tc["tool"], "args" => tc["args"] } }
+            }
+            tool_calls.each do |tc|
+              args = tc["args"].is_a?(Hash) ? tc["args"] : {}
+              action = args["action"].to_s
+              first_recall_turn ||= turns if tc["tool"] == "vakanuvis" && (action.empty? || action == "recall")
+              result = tools.execute(tc["tool"], args)
+              calls << [tc["tool"], args, result]
+              history << { role: "tool", tool_call_id: tc["id"], tool_name: tc["tool"], content: result.to_s }
+            end
+          end
+
+          { turns: turns, answer: answer, calls: calls, first_recall_turn: first_recall_turn, hit_cap: answer.empty? }
+        end
+      end
+
+      # ---- metrikler --------------------------------------------------------
+
+      Metrics = Struct.new(
+        :label, :recall_called, :first_recall_turn, :recall_calls, :avg_query_terms,
+        :keywords_line_used, :recall_empty_rate, :record_called, :wrong_path_puts,
+        :answer_used_recall, :hit_turn_cap, keyword_init: true
+      ) do
+        def summary
+          "recall=#{recall_called ? "turn #{first_recall_turn}" : 'never'} calls=#{recall_calls} " \
+            "terms=#{avg_query_terms || '-'} kw=#{keywords_line_used ? 'yes' : 'no'} empty=#{recall_empty_rate || '-'}% " \
+            "record=#{record_called ? 'vakanuvis' : 'none'} wrong_put=#{wrong_path_puts} " \
+            "answer_used=#{answer_used_recall ? 'yes' : 'no'}"
+        end
+      end
+
+      def metrics_for(label, task_runs)
+        recall_events = []
+        record_calls = 0
+        wrong_puts = 0
+        first_recall_turn = nil
+        answer_used = false
+        hit_cap = false
+
+        task_runs.each do |run|
+          run[:calls].each do |name, args, result|
+            if name == "vakanuvis"
+              action = args["action"].to_s
+              if action.empty? || action == "recall"
+                recall_events << [args["query"].to_s, result.to_s]
+                first_recall_turn ||= run[:first_recall_turn]
+              elsif action == "record"
+                record_calls += 1
+              end
+            elsif name == "storage" && args["action"].to_s == "put" && ["memory", "wiki"].include?(args["type"].to_s)
+              wrong_puts += 1 # kronikçi masada DURUYORKEN doğrudan put = yanlış yol
+            end
+          end
+          answer_used ||= answer_uses_recall?(run[:answer])
+          hit_cap ||= run[:hit_cap] == true
+        end
+
+        terms = recall_events.map { |query, _res| query.strip.split(/\s+/).reject(&:empty?).size }
+        Metrics.new(
+          label: label,
+          recall_called: !recall_events.empty?,
+          first_recall_turn: first_recall_turn,
+          recall_calls: recall_events.size,
+          avg_query_terms: terms.empty? ? nil : terms.sum.fdiv(terms.size).round(1),
+          keywords_line_used: recall_events.any? { |query, _res| query.include?("Keywords:") },
+          recall_empty_rate: recall_events.empty? ? nil : empty_rate(recall_events),
+          record_called: record_calls.positive?,
+          wrong_path_puts: wrong_puts,
+          answer_used_recall: answer_used,
+          hit_turn_cap: hit_cap
+        )
+      end
+
+      # "Recalled N ..." başlığı dışındaki her şey (anahtar-AND boş + yalnız
+      # fallback izleri) boş sayılır — issue'nin "fallback dahil" tanımı.
+      def empty_rate(recall_events)
+        empty_count = recall_events.count { |_query, res| !res.start_with?("Recalled ") }
+        (empty_count.fdiv(recall_events.size) * 100).round(0)
+      end
+
+      def answer_uses_recall?(text)
+        text = text.to_s
+        text.match?(ANSWER_MARKER_BACKOFF) && text.match?(ANSWER_MARKER_TRIES)
+      end
+
+      # ---- koşu -------------------------------------------------------------
+
+      # Her sürücü özgün tohumlu mağaza alır (izolasyon: record yan
+      # etkileri sızamaz). Sürücü hatası TEK modeli tablodan düşürür —
+      # diğer modellerin ölçümü yaşamaya devam eder; düşen satır sınıfa
+      # göre ayrışır: RateLimitError → SkipRow (kota/ağ ölümü — geçici),
+      # diğer her şey → ErrorRow (kimlik doğrulama, bozuk JSON, determin-
+      # istik düzlemde script hatası... bunlar "skipped" kıyafetini taşımaya
+      # değmez). Deterministik düzlemde çöküş loud: diğer bench metotları
+      # gibi rake bench'i kırmalı — çökme "skipped" diye kaydedilmez.
+      def run(drivers, io: $stdout)
+        drivers.map do |driver|
+          root = Dir.mktmpdir("rubik_vakanuvis_adoption")
+          begin
+            store = seed_store(root)
+            harness = Rubik::Storage::Vakanuvis::Harness.new(store: store, config: QuietConfig.new, session_slug: "bench-#{driver.label}")
+            tools = ToolBench.new(store, harness)
+            runs = TASKS.map { |task| driver.run_task(task, tools) }
+            tool_errors = runs.sum { |r| r[:calls].count { |_n, _a, res| TOOL_ERROR_MARKERS.any? { |m| res.to_s.start_with?(m) } } }
+            if tool_errors.positive?
+              first_bad = runs.flat_map { |r| r[:calls] }.find { |_n, _a, res| TOOL_ERROR_MARKERS.any? { |m| res.to_s.start_with?(m) } }
+              raise "#{driver.label}: #{tool_errors} tool error(s) — the bench toolbelt itself failed; " \
+                    "these numbers would read as model behavior. first: #{first_bad[2].to_s[0, 160]}"
+            end
+            harness.shutdown
+            metrics_for(driver.label, runs).tap { |m| io&.puts("  [vakanuvis-adoption] #{m.label}: #{m.summary}") }
+          rescue Rubik::LLM::RateLimitError => e
+            location = (e.backtrace || []).first
+            io&.puts("  [vakanuvis-adoption] #{driver.label}: SKIPPED (rate limited) — #{e.message} @ #{location}")
+            SkipRow.new(driver.label, e)
+          rescue Rubik::LLM::ClientError, StandardError => e
+            # Deterministik düzlem: asla satıra dönüşmesin (rake bench
+            # loud patlar). Canlı düzlem: tek bozuk sürücü kalan modellerin
+            # ölçümünü öldürmesin — dürüst ERROR satırı düşer.
+            raise unless driver.live?
+
+            location = (e.backtrace || []).first
+            io&.puts("  [vakanuvis-adoption] #{driver.label}: ERROR — #{e.class}: #{e.message} @ #{location}")
+            ErrorRow.new(driver.label, e)
+          ensure
+            begin
+              FileUtils.remove_entry(root)
+            rescue StandardError => e
+              # Windows EBUSY/ENOTEMPTY (AV tarayıcı, indeksleyici) cleanup'ı
+              # patlatabilir — cleanup hatası tabloyu ve işlenen hatayı
+              # MaskeleMEsin; tüm benchmark'ı da abort etmesin.
+              warn "  [vakanuvis-adoption] cleanup failed for #{root}: #{e.class}: #{e.message}"
+            end
+          end
+        end
+      end
+
+      # Kota/ağ ölümü yaşayan modelin tablo satırı: yok saymak değil —
+      # "ölçülemedi"yi tabloda göster (sessiz-satır-kaybı yok).
+      SkipRow = Struct.new(:label, :error) do
+        def summary = "skipped: #{error.class}: #{error.message.to_s[0, 120]}"
+      end
+
+      # Kota DEĞİL — kimlik doğrulama, bozuk sağlayıcı yanıtı, kabuk...
+      # "skipped" yalan olur; tabloda error diye ayrışır.
+      ErrorRow = Struct.new(:label, :error) do
+        def summary = "error: #{error.class}: #{error.message.to_s[0, 120]}"
+      end
+
+      # Bench tarafı araç hataları (ToolBench#execute'un kurtarma dizgileri):
+      # bunlar model davranışı DEĞİL — metrik borusuna girmeden yakalanır.
+      TOOL_ERROR_MARKERS = ["tool error: ", "Unknown tool "].freeze
+
+      # Metrik satırlarından runner sonuçları: hedef taban çizgisi (model
+      # puanı değil — senaryo KOŞTU mu). Tablo io'ya markdown düşer.
+      def metric_results(rows, io: $stdout)
+        io&.puts("\n#### Vakanüvis tool adoption (issue #338)\n")
+        io&.puts("| model | recall | first@ | calls | terms | kw:line | empty% | record | wrong put | answer used |")
+        io&.puts("|---|---|---|---|---|---|---|---|---|---|")
+        rows.map do |m|
+          if m.is_a?(SkipRow) || m.is_a?(ErrorRow)
+            # Ölçülemeyen model tabloda KALIR — satır kaybı sessiz değil;
+            # kota ölümü (skipped) ile gerçek hata (error) ayrışır.
+            status = m.is_a?(SkipRow) ? "skipped" : "error"
+            # 10 hücre: başlık 10 sütun — 11. hücreye düşen skip/error
+            # gerekçesi GFM tarafından SESSİZCE düşürülüyordu.
+            io&.puts("| #{m.label} | #{status} | - | - | - | - | - | - | - | (#{m.summary}) |")
+            next Rubik::Benchmark::MetricResult.new(
+              name: "Vakanüvis Tool Adoption — #{m.label}",
+              target: "baseline (issue #338)",
+              measured: m.summary,
+              passed: false
+            )
+          end
+          io&.puts("| #{m.label} | #{m.recall_called ? 'yes' : 'NO'} | #{m.first_recall_turn || '-'} | #{m.recall_calls} | " \
+                   "#{m.avg_query_terms || '-'} | #{m.keywords_line_used ? 'yes' : 'no'} | #{m.recall_empty_rate || '-'}% | " \
+                   "#{m.record_called ? 'vakanuvis' : 'none'} | #{m.wrong_path_puts} | #{m.answer_used_recall ? 'yes' : 'no'} |")
+          Rubik::Benchmark::MetricResult.new(
+            name: "Vakanüvis Tool Adoption — #{m.label}",
+            target: "baseline (issue #338)",
+            measured: m.summary,
+            passed: true
+          )
+        end
+      end
+
+      # Replay script'leri: her adım {call: [name, args]} | {call_each: [[name,
+      # args], ...]} | {answer: "..."} — ReplayDriver bunları GERÇEK
+      # araçlarla sırayla koşturur; yanıtlar profilin davranış taahhüdüdür.
+      SCRIPTS = {
+        "adopter" => {
+          "recall-tr-en" => [
+            { call: ["vakanuvis", { "action" => "recall", "query" => "gateway retry backoff 429" }] },
+            { answer: "Üstel geri çekilme: 2s, 4s, 8s — en fazla 5 deneme; 30 ardışık hata sonra devre kesici açılır." }
+          ],
+          "durable-conclusion" => [
+            { call: ["vakanuvis", { "action" => "record", "topic" => "digest gate dedupe",
+                                    "body" => "Same-target digest jobs are deduplicated; queue cap is 8 jobs, one in-flight per target.\n" \
+                                              "Keywords: digest dedupe gate queue target" }] },
+            { answer: "Recorded as a memory card via the chronicler." }
+          ]
+        },
+        "wrong-path" => {
+          "recall-tr-en" => [
+            { answer: "Bilmiyorum; geçidi yeniden dene ve sonra tekrar sor." }
+          ],
+          "durable-conclusion" => [
+            { call_each: [["storage", { "action" => "put", "type" => "memory", "title" => "digest dedupe",
+                                        "body" => "Same-target digest jobs are deduplicated." }]] },
+            { answer: "Persisted directly to storage." }
+          ]
+        },
+        "struggler" => {
+          "recall-tr-en" => [
+            { call: ["vakanuvis", { "action" => "recall", "query" => "gateway hangi durumlarda üstel bekleme uygular ve devre kesici kaç hata sonra açılır" }] },
+            { call: ["vakanuvis", { "action" => "recall", "query" => "gateway retry backoff" }] },
+            { answer: "2s, 4s, 8s üstel geri çekilme uygulanır (en fazla 5 deneme)." }
+          ],
+          "durable-conclusion" => [
+            { call: ["vakanuvis", { "action" => "record", "topic" => "digest gate dedupe",
+                                    "body" => "Same-target digest jobs are deduplicated." }] },
+            { answer: "Saved via vakanuvis record." }
+          ]
+        }
+      }.freeze
+    end
+  end
+end

data/lib/rubik/log.rb

@@ -6,9 +6,10 @@
 # follows the repo's [rubik] prefix convention. Emit is error-isolated: a
 # logger must never raise, least of all from inside a rescue body.
 #
-# warn/error always print (current behavior). debug/info are filtered by
-# RUBIK_LOG_LEVEL (default "warn"); the RUBIK_DEBUG-gated debug_warn stays a
-# separate mechanism and is NOT migrated by this slice.
+# warn/error always print at the DEFAULT level. debug/info/warn are all
+# filtered by RUBIK_LOG_LEVEL (default "warn") — an operator running at
+# "error" also silences :warn, by design. The RUBIK_DEBUG-gated debug_warn
+# stays a separate mechanism and is NOT migrated by this slice.
 module Rubik
   module Log
     LEVELS = { debug: 0, info: 1, warn: 2, error: 3 }.freeze

data/lib/rubik/orchestrator/step_executor.rb

@@ -176,9 +176,9 @@ module Rubik
       end
 
       def normalize_raw_output(raw_output, tool_name, call_id, dur)
-        max_chars = @deps.shell&.config&.fetch("tools.max_output_chars", 12_000) || 12_000
-        max_lines = @deps.shell&.config&.fetch("tools.max_output_lines", 300) || 300
-        trunc_strat = @deps.shell&.config&.fetch("tools.truncation_strategy", "head_tail") || "head_tail"
+        max_chars = @deps.shell&.config&.fetch("tools.max_output_chars", Rubik::Tools::Truncator::DEFAULT_MAX_CHARS) || Rubik::Tools::Truncator::DEFAULT_MAX_CHARS
+        max_lines = @deps.shell&.config&.fetch("tools.max_output_lines", Rubik::Tools::Truncator::DEFAULT_MAX_LINES) || Rubik::Tools::Truncator::DEFAULT_MAX_LINES
+        trunc_strat = Rubik::Tools::Truncator.resolve_strategy(@deps.shell&.config&.fetch("tools.truncation_strategy", Rubik::Tools::Truncator::DEFAULT_STRATEGY))
 
         if raw_output.is_a?(Rubik::Tools::Result)
           trunc_res = Rubik::Tools::Truncator.truncate(raw_output.output, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)

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

@@ -17,41 +17,61 @@ module Rubik
           return error_result(name, "Tool '#{name}' is not available in subagent toolset.") unless tool
 
           raw = tool.execute(args)
-          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
-          normalize_tool_result(raw, name, max_chars: max_chars.to_i, max_lines: max_lines.to_i)
+          cfg = @config.respond_to?(:fetch) ? @config : nil
+          max_chars = (cfg&.fetch("tools.max_output_chars", Rubik::Tools::Truncator::DEFAULT_MAX_CHARS) || Rubik::Tools::Truncator::DEFAULT_MAX_CHARS).to_i
+          max_lines = (cfg&.fetch("tools.max_output_lines", Rubik::Tools::Truncator::DEFAULT_MAX_LINES) || Rubik::Tools::Truncator::DEFAULT_MAX_LINES).to_i
+          strategy = Rubik::Tools::Truncator.resolve_strategy(cfg&.fetch("tools.truncation_strategy", Rubik::Tools::Truncator::DEFAULT_STRATEGY))
+          normalize_tool_result(raw, name, max_chars: max_chars, max_lines: max_lines, strategy: strategy)
         rescue StandardError => e
           error_result(name, "Tool execution error: #{e.class}: #{e.message}", error: e.message)
         end
 
         private
 
-        def normalize_tool_result(raw, name, max_chars:, max_lines:)
+        def normalize_tool_result(raw, name, max_chars:, max_lines:, strategy: Rubik::Tools::Truncator::DEFAULT_STRATEGY)
           if raw.is_a?(Rubik::Tools::Result)
-            trunc = Rubik::Tools::Truncator.truncate(raw.output, max_chars: max_chars, max_lines: max_lines)
+            trunc = Rubik::Tools::Truncator.truncate(raw.output, max_chars: max_chars, max_lines: max_lines, strategy: strategy)
             # Truncation only shortens the display text — status, exit code,
             # metadata and the original truncation flag all survive it.
+            first_line = raw.output.to_s.lines.first.to_s.strip
             Rubik::Tools::Result.new(tool_name: raw.tool_name.to_s.empty? ? name : raw.tool_name,
-                                     status: raw.status, error: raw.error, exit_code: raw.exit_code,
+                                     status: raw.status,
+                                     error: raw.error || (raw.error? ? first_line : nil), exit_code: raw.exit_code,
                                      output: trunc[:text], duration_ms: raw.duration_ms,
                                      truncated: raw.truncated || trunc[:truncated], metadata: raw.metadata)
           elsif raw.respond_to?(:status) && raw.respond_to?(:output)
             out_str = raw.output.to_s
-            trunc = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars, max_lines: max_lines)
-            Rubik::Tools::Result.new(tool_name: name, status: raw.status.to_sym, output: trunc[:text],
-                                     truncated: trunc[:truncated],
+            trunc = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars, max_lines: max_lines, strategy: strategy)
+            first_line = out_str.lines.first.to_s.strip
+            status = raw.status.to_sym
+            Rubik::Tools::Result.new(tool_name: name, status: status,
+                                     error: (raw.respond_to?(:error) && raw.error) || (status == :error ? first_line : nil),
+                                     output: trunc[:text], truncated: trunc[:truncated],
                                      exit_code: raw.respond_to?(:exit_code) ? raw.exit_code : nil,
                                      metadata: raw.respond_to?(:metadata) ? raw.metadata : {})
           else
             out_str = raw.to_s
-            trunc = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars, max_lines: max_lines)
-            status = raw.respond_to?(:error?) && raw.error? ? :error : :ok
+            trunc = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars, max_lines: max_lines, strategy: strategy)
+            status = classify_raw_string(raw, out_str)
             Rubik::Tools::Result.new(tool_name: name, status: status,
                                      error: status == :error ? out_str.lines.first.to_s.strip : nil,
                                      output: trunc[:text], truncated: trunc[:truncated])
           end
         end
 
+        # Root-parity string classification (arch scan card 5, review F1): the
+        # same lexicon as StepExecutor#normalize_raw_output's else branch —
+        # error?/failed? predicates, then the shared ERROR_PREFIXES table.
+        # Without this, a bare "Error: ..." string reads status=ok in subagent
+        # history while the root plane honestly reports :error.
+        def classify_raw_string(raw, out_str)
+          return :error if raw.respond_to?(:error?) && raw.error?
+          return :error if raw.respond_to?(:failed?) && raw.failed?
+          return :error if raw.is_a?(String) && Rubik::Orchestrator::StepExecutor::ERROR_PREFIXES.any? { |pfx| out_str.start_with?(pfx) }
+
+          :ok
+        end
+
         def error_result(name, text, error: nil)
           Rubik::Tools::Result.new(tool_name: name, status: :error, output: text, error: error || text)
         end

data/lib/rubik/prompt/emergency_compactor.rb

@@ -52,9 +52,13 @@ module Rubik
         # "head_tail" (default, original behavior) keeps head + tail around the
         # omission notice; "head_only" keeps the message head — useful when the
         # actionable guidance at the tail must not crowd out the error header.
-        # Truncator normalizes strings/symbols and falls back to head_tail on
-        # unknown values.
-        strategy = config["emergency_truncate_strategy"] || config[:emergency_truncate_strategy] || "head_tail"
+        # Truncator.resolve_strategy normalizes strings/symbols, falls back to
+        # head_tail on unknown values AND warns once — the same typo-honesty
+        # contract as the tools.truncation_strategy knob (issue #349).
+        strategy = Rubik::Tools::Truncator.resolve_strategy(
+          config["emergency_truncate_strategy"] || config[:emergency_truncate_strategy],
+          key: "context.emergency_truncate_strategy"
+        )
 
         history.each do |msg|
           next unless ConversationRows.row?(msg)

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

@@ -270,6 +270,13 @@ module Rubik
         private_class_method def self.suspend_goal_turn(ctx, orchestrator:, goal_state:, goal_ledger:,
                                                         goal_text:, goal_id:, record_pair:, reason:, tokens: nil)
           attempt = suspended_attempt(ctx, goal_id) + 1
+          # Ledger kimliği askıdan ÖNCE okunur: suspend! → ledger.suspend!
+          # sırası metanın bu turun token'larını içermesi için zorunlu,
+          # ama o damga storage_id'yi değiştirdiği için sonradan atanan id
+          # SUSPEND_EVENT'e geç kalırdı — ilk askıda kronik satırı slug
+          # kimliğine düşer, ledger= bağlantısı kaybolurdu.
+          # resume_cross_process ile aynı uçuş-içi atama önceliği.
+          goal_state.ledger_id = goal_ledger.snapshot[:storage_id] if goal_ledger
           goal_state.suspend!(reason, tokens: tokens)
           goal_ledger&.suspend!(suspend_stamp_meta(goal_state, goal_id, reason, attempt))
           registry = goal_registry_for(ctx)

data/lib/rubik/repl/input_execution.rb

@@ -82,7 +82,11 @@ module Rubik
               clean_raw = Rubik::Security::Redactor.redact(parsed.raw)
               @recorder&.record_repl_command(clean_raw, output_text)
               # Plan 61 D-8: bound what a bang command leaves in LLM memory; the recorder keeps the full text.
-              trunc = Rubik::Tools::Truncator.truncate(output_text, max_chars: @config.fetch("tools.max_output_chars", 12_000), strategy: :head_tail)
+              max_chars = @config.fetch("tools.max_output_chars", Rubik::Tools::Truncator::DEFAULT_MAX_CHARS)
+              # Deliberately context-scoped (issue #349 F8): truncation_strategy is a
+              # tool-output contract (the two orchestrator planes); bang-command echo
+              # is REPL history capture and stays head_tail, outside the knob's promise.
+              trunc = Rubik::Tools::Truncator.truncate(output_text, max_chars: max_chars, strategy: :head_tail)
               @conversation_history << { role: "user", content: clean_raw.delete_prefix("!") } # bangs stay out of LLM history; recorder keeps the literal
               @conversation_history << { role: "assistant", content: trunc[:truncated] ? trunc[:text] : output_text }
               trim_conversation_window!

data/lib/rubik/storage/vakanuvis/annal_writer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "digest"
+
 module Rubik
   module Storage
     module Vakanuvis
@@ -35,6 +37,44 @@ module Rubik
           [["goal.#{payload[:goal_ordinal]}.#{state}", "#{head} (event=goal.#{payload[:goal_ordinal]}.#{state})"]]
         end
 
+        # Askı satırı (issue #350): anahtar PEEK sırası DEĞİL hedef
+        # kimliğidir. Askı peek'lediği sıraya ait görünür; araya başka bir
+        # goal bitişi girerse peek yanlış kayda bağlanır, iki askı aynı
+        # peek'i paylaşınca dedup ikinci satırı yutar. Kimlik = ledger_id
+        # (goal.ledger açıkken post_lifecycle'nin damgası), yoksa goal
+        # metninin slug'ı; steps + hata özeti anahtara işlenir — gerçek
+        # yeniden teslim düşer, içerik değişen askı kalır. Satır goal=
+        # tek-satırını da taşır: sıra bağlantısı kalkınca metnin kendisi
+        # dürüst bağdır (goal kaydı askıda henüz mint edilmez).
+        def suspend_line(seq, payload)
+          ledger = payload[:ledger_id].to_s
+          identity = ledger.empty? ? Vocabulary.slug(payload[:goal]) : ledger
+          head = "- [#{seq}] goal status=suspended steps=#{payload[:steps]}/#{payload[:max_steps]}"
+          head += " error=#{one_line(payload[:last_error], 80)}" unless payload[:last_error].to_s.empty?
+          head += " ledger=#{one_line(ledger, 40)}" unless ledger.empty?
+          head += " goal=#{one_line(payload[:goal], 60)}"
+          error = payload[:last_error].to_s
+          err_part = error.empty? ? "ok" : Digest::SHA256.hexdigest(error)[0, 8]
+          key = "goal.suspend.#{identity}.#{payload[:steps]}.#{err_part}"
+          [[key, "#{head} (event=#{key})"]]
+        end
+
+        # Olay-kimliği eki (issue #351 F7): handle_event'in kurtarma
+        # günlüğü tek başına kind ile askı satırını bitiş satırından
+        # ayırt edemez — düşen kronik satırının kimliği status + goal
+        # tek-satırıdır (bitiş ayrıca maintain(goal_end: true)'i atlar).
+        # Üretilemezse boş dizgi; günlük satırı asla patlamaz.
+        def event_context(kind, payload)
+          return "" unless payload.is_a?(Hash)
+
+          case kind
+          when :goal then " status=#{payload[:status]} goal=#{one_line(payload[:goal], 40)}"
+          when :subagent then " id=#{payload[:storage_id] || payload[:id]} state=#{payload[:state]}"
+          when :turn then " kind=#{payload[:kind]} prompt=#{one_line(payload[:prompt], 40)}"
+          else ""
+          end
+        end
+
         # Kök-turn satırı (root-turn planı 2026-10-04): REPL turn'ünün
         # deterministik özeti. Boş alan (tools/tokens) satırda görünmez;
         # ordinal harness-lokal sayaçtan gelir, anahtar turn.<n>.<kind>.
@@ -64,13 +104,20 @@ module Rubik
           "goal: #{text}"
         end
 
-        # Satır ekleme + tekilleştirme: body'de anahtarı olan satır bir
-        # daha yazılmaz (olay yeniden teslimi — resume sonrası ikinci
-        # tamamlanma gibi — yinelenen satır açmaz).
+        # Satır ekleme + tekilleştirme: body'de SATIR SONU (event=anahtar)
+        # taşıyan satır bir daha yazılmaz (olay yeniden teslimi — resume
+        # sonrası ikinci tamamlanma gibi — yinelenen satır açmaz). Bağ
+        # (end_with?) zorunludur: serbest metin alanları (goal=, error=,
+        # prompt= …) bir "(event=X)" dizgisi TAŞIYABİLİR; gövde-geniş
+        # include taraması o dizgiyi sahte anahtar sayıp gelecekteki
+        # gerçek X satırını sessizce yutardı (review #353: zehirlenmiş
+        # dedup). Anahtar daima satırı bitirdiğinden bağ tarama hem dürüst
+        # hem ucuzdur.
         def append(store, ref:, title:, tags: Vocabulary::ANNAL_TAGS, links: {}, lines: [])
           existing = store.get(type: "note", id: ref)
           body = existing ? existing["body"].to_s : ""
-          fresh = lines.reject { |key, _line| body.include?("(event=#{key})") }
+          settled = body.lines.map(&:rstrip)
+          fresh = lines.reject { |key, _line| settled.any? { |l| l.end_with?("(event=#{key})") } }
           return existing if existing && fresh.empty?
 
           merged = ([body] + fresh.map { |_key, line| line }).reject { |l| l.to_s.strip.empty? }.join("\n")

data/lib/rubik/storage/vakanuvis/distill_gate.rb

@@ -25,11 +25,13 @@ module Rubik
         # v2 §4-V6: öneri sonundaki smoke-test sorgularının sayı sınırı.
         CHECK_LIMIT = 5
 
-        def receipt(query:, target:, spawned:)
+        def receipt(query:, target:, spawned:, spawn_failed: false)
           head = "Digest queued (async): the chronicler will compile '#{AnnalWriter.one_line(query, 80)}' into '#{target}'."
           tail = if spawned
                    "This call did NOT wait for the LLM — conclude your turn; recall it later with " \
                      "vakanuvis(action: 'recall', query: '...') once compiled."
+                 elsif spawn_failed
+                   "The distiller spawn attempt failed (see dmesg) — the job stays queued and the spawn retries with the next digest or flush."
                  else
                    "No distiller run started yet (subagents.vakanuvis.distiller or the chronicler type may be " \
                      "disabled) — the job stays queued and compiles when the distiller becomes available."
@@ -37,6 +39,16 @@ module Rubik
           "#{head} #{tail}"
         end
 
+        def duplicate_receipt(query, target)
+          "Digest already queued for '#{target}' (#{AnnalWriter.one_line(query, 60)}): the chronicler is " \
+            "compiling it — recall it later with vakanuvis(action: 'recall', query: '...')."
+        end
+
+        def full_receipt(target, capacity)
+          "Digest not accepted for '#{target}': capacity #{capacity} is full. " \
+            "Existing jobs are preserved; retry after a digest finishes."
+        end
+
         # Öneri şeması: ilk satır hedef ref (wiki.<slug>), gerisi gövde;
         # gövde sonunda isteğe bağlı `CHECK: <sorgu>` satırları (v2 §4-V6
         # smoke testi — en fazla CHECK_LIMIT adet, gövdeden AYIKLANIR,
@@ -128,7 +140,7 @@ module Rubik
                        "read_file(path: '#{annal_uri}')"
           end
           Array(job[:transcript_uris]).each { |u| sources << "- Transcript: read_file(path: '#{u}')" }
-          sources << "- Goal record: read_file(path: '#{store.uri_for('goal', job[:goal_id])}')" if job[:goal_id]
+          sources << "- Goal record: read_file(path: '#{store.uri_for('note', Vocabulary.goal_ref(job[:goal_ordinal]))}')" if job[:goal_ordinal]
           if (gaps = open_recall_gaps(store))
             sources << gaps
           end

data/lib/rubik/storage/vakanuvis/gate.rb

@@ -58,7 +58,9 @@ module Rubik
           # submit_with_status aynı kabulü [makbuz, durum] ikilisi olarak
           # verir (:accepted|:duplicate|:full) — otomatik damıtım red'i
           # makbuz dizgesinden ayırt edebilsin diye (review #346).
-          def submit_with_status(query, spawn: true)
+          # goal_ordinal: goal-end auto-digest'in kanıt hedefi (tarama kartı 1,
+          # 2026-11-01) — işe işlenir, brief goal kaydını kaynak gösterir.
+          def submit_with_status(query, spawn: true, goal_ordinal: nil)
             target = Vocabulary.wiki_ref(query)
             # v2 §4-V5: aynı hedefli iş zaten kuyrukta ya da uçuştaysa makbuz
             # 'already queued' varyantına düşer — çift doğum yok.
@@ -66,21 +68,18 @@ module Rubik
               next :duplicate if @digest_targets.key?(target)
               next :full if @digest_targets.size >= @max_digest_jobs
 
-              @pending_digests << { query: query, target: target, transcript_uris: source_transcript_uris }
+              @pending_digests << Job.new(query: query, target: target, transcript_uris: source_transcript_uris, goal_ordinal: goal_ordinal)
               @digest_targets[target] = true
               :accepted
             end
-            if admission == :duplicate
-              return ["Digest already queued for '#{target}' (#{AnnalWriter.one_line(query, 60)}): the chronicler is " \
-                      "compiling it — recall it later with vakanuvis(action: 'recall', query: '...').", admission]
-            end
-            if admission == :full
-              return ["Digest not accepted for '#{target}': capacity #{@max_digest_jobs} is full. " \
-                      "Existing jobs are preserved; retry after a digest finishes.", admission]
-            end
+            return [DistillGate.duplicate_receipt(query, target), admission] if admission == :duplicate
+
+            return [DistillGate.full_receipt(target, @max_digest_jobs), admission] if admission == :full
 
             spawned = spawn ? spawn_job!(batch: false) : nil
-            [DistillGate.receipt(query: query, target: target, spawned: !spawned.nil?), admission]
+            # REVIEW: patlak doğum "disabled" makbuzuyla yalanlanmasın (F2).
+            failed_spawn = spawn && spawned.nil? && spawn_allowed?
+            [DistillGate.receipt(query: query, target: target, spawned: !spawned.nil?, spawn_failed: failed_spawn), admission]
           end
 
           def submit(query, spawn: true) = submit_with_status(query, spawn: spawn)[0]
@@ -150,7 +149,7 @@ module Rubik
           # Salt-okunuma peeki (test/kurcalama yüzeyi): kuyruğun başını
           # gösterir — tüketmez. Üretim görünürlüğü aşağıdaki job_targets'tır.
           def peek_job(batch: false)
-            @lock.synchronize { @pending_digests.first || (batch ? { batch: true } : nil) }
+            @lock.synchronize { @pending_digests.first || (batch ? Job.new(batch: true) : nil) }
           end
 
           # İş defteri görünümü (issue #100 P2b): kuyruktaki + uçuştaki
@@ -219,11 +218,15 @@ module Rubik
               @supervisor.respond_to?(:spawn) &&
               @supervisor.respond_to?(:type_registry) && @supervisor.type_registry.get(TYPE_NAME)
           end
+          # Genel durum sorgusu (inceleme turu 2): Harness, kabul edilen
+          # digest topic'lerinin hiç derlenemeyeceğini dürüstçe
+          # bildirmek için doğum kapısını sorabilir olmalı.
+          public :spawn_allowed?
 
           # Aşağısı YALNIZ @lock altından çağrılır (çağıran: submit /
           # spawn_job! / completion_event) — kendi kilidi almaz.
           def claim_job(batch: false)
-            @pending_digests.shift || (batch ? { batch: true, transcript_uris: source_transcript_uris } : nil)
+            @pending_digests.shift || (batch ? Job.new(batch: true, transcript_uris: source_transcript_uris) : nil)
           end
 
           def restore_job(job)

data/lib/rubik/storage/vakanuvis/harness.rb

@@ -27,6 +27,9 @@ module Rubik
         SUBAGENT_EVENT = :subagent_completed
         GOAL_EVENT = :goal_finished
         TURN_EVENT = :turn_finished
+        # Askı kroniği (tarama kartı 2, 2026-11-01): GoalState::SUSPEND_EVENT — abonelik
+        # :goal akışına yazar; worker status=="suspended" ile ayırt eder.
+        SUSPEND_EVENT = :goal_suspended
 
         attr_reader :store, :config, :supervisor, :dmesg, :session_slug, :gate
 
@@ -269,6 +272,7 @@ module Rubik
 
           @event_bus.subscribe(SUBAGENT_EVENT, context: @context) { |p| enqueue_event(:subagent, p) }
           @event_bus.subscribe(GOAL_EVENT, context: @context) { |p| enqueue_event(:goal, p) }
+          @event_bus.subscribe(SUSPEND_EVENT, context: @context) { |p| enqueue_event(:goal, p) }
           @event_bus.subscribe(TURN_EVENT, context: @context) { |p| enqueue_event(:turn, p) } if @root_turns
         end
 
@@ -295,13 +299,19 @@ module Rubik
             break if kind == STOP
 
             handle_event(kind, payload)
+          rescue StandardError => e
+            # Last-ditch net: a raise escaping handle_event's own rescue
+            # would kill the worker with queued events unconsumed — and
+            # shutdown's alive?-check stays blind to that loss.
+            Vakanuvis.log_via(@dmesg, :warn, "chronicler worker event dispatch failed (#{e.class}: #{e.message}) — worker continues")
           ensure
             @monitor.synchronize { @busy -= 1 }
           end
         end
 
         # TranscriptIndexer disiplini: kronikçinin kendi hatası akışı
-        # asla bozmaz — uyarı düşer, sonraki olay işlenir.
+        # asla bozmaz — uyarı düşer, sonraki olay işlenir. Kimlik eki
+        # (F7) AnnalWriter.event_context'te.
         def handle_event(kind, payload)
           case kind
           when :subagent then handle_subagent(payload)
@@ -309,7 +319,9 @@ module Rubik
           when :turn then handle_turn(payload)
           end
         rescue StandardError => e
-          Vakanuvis.log_via(@dmesg, :warn, "event handling failed (#{kind}): #{e.class}: #{e.message}")
+          # İlk backtrace karesi (event_loop.rb kuralı): depo hatasını
+          # annal/digest hatasından ayırt eder.
+          Vakanuvis.log_via(@dmesg, :warn, "event handling failed (#{kind}#{AnnalWriter.event_context(kind, payload)}): #{e.class}: #{e.message} @ #{(e.backtrace || []).first}")
         end
 
         def handle_subagent(payload)
@@ -336,6 +348,10 @@ module Rubik
         end
 
         def handle_goal(payload)
+          if payload[:status].to_s == "suspended" # askı kroniği: satır düşer, mint/upsert/maintain yok (kart 2)
+            seq = next_seq # anahtar hedef kimliği — sıra peek'i değil (issue #350)
+            return append_session(AnnalWriter.suspend_line(seq, payload))
+          end
           ordinal = next_goal_ordinal
           enriched = payload.merge(goal_ordinal: ordinal)
           seq = next_seq
@@ -344,17 +360,16 @@ module Rubik
                                    title: AnnalWriter.goal_title(ordinal, enriched[:goal]), body: goal_body.join("\n"),
                                    tags: Vocabulary::ANNAL_TAGS + [Vocabulary::GOAL_TAG], links: { "session" => Vocabulary.session_ref(@session_slug) })
           append_session(AnnalWriter.goal_lines(seq, enriched))
-          maintain(goal_end: true)
+          maintain(goal_end: true, goal_ordinal: ordinal)
         end
 
         # Goal sırası mağazadan türetilir (refs'teki en büyük annal.goal.<n>
-        # + 1): süreç yeniden başlasa bile aynı depoda numara çakışmaz —
-        # determinizm depo durumundan, saatlerden değil.
-        def next_goal_ordinal
-          @monitor.synchronize do
-            max_ref = @store.refs.keys.filter_map { |k| Vocabulary.goal_ordinal(k) }.max.to_i
-            @goal_ordinal = [@goal_ordinal, max_ref].max + 1
-          end
+        # + 1): süreç yeniden başlasa bile aynı depoda numara çakışmaz.
+        # Askı artık peek ETMEZ (issue #350) — sıra yalnız bitişte mint edilir.
+        def next_goal_ordinal = @goal_ordinal = peek_goal_ordinal
+
+        def peek_goal_ordinal
+          @monitor.synchronize { [@goal_ordinal, @store.refs.keys.filter_map { |k| Vocabulary.goal_ordinal(k) }.max.to_i].max + 1 }
         end
 
         # Flush sayacı (R8): subagent ve turn olayları aynı ölçüde sayılır;
@@ -372,13 +387,13 @@ module Rubik
         # yeniden hesap + dokunulan hafıza konularının otomatik damıtımı +
         # damıtıcı doğum kararı. v2 §4-V5: toplu doğum yalnızca kirli işaretle;
         # hedefli damıtım TÜM konuları kuyrukladıysa toplu doğum atlanır — kayıp/red varsa batch telafi eder.
-        def maintain(goal_end: false)
+        def maintain(goal_end: false, goal_ordinal: nil)
           # Sweep record() ile aynı kilide koşar (tek-yazar disiplini):
           # get-then-put dansı çift satır açamaz.
           swept = @monitor.synchronize { MemorySteward.sweep_rogue_memory(@store) }
           Vakanuvis.log_via(@dmesg, :info, "steward swept #{swept} rogue memory row(s)") if swept.positive?
           WikiSkeleton.rebuild_home(@store)
-          digested = auto_digest_touched!(spawn: !stopped?) if goal_end
+          digested = auto_digest_touched!(spawn: !stopped?, goal_ordinal: goal_ordinal) if goal_end
           @gate.flush_tick unless stopped? || digested
         end
 
@@ -387,7 +402,7 @@ module Rubik
         # spawn=false (kapanış) zombi LLM doğumunu engeller. Konu-başı yalıtım
         # (review #346): tek başarısız/red'li submit kalan konuları kaybettirmez —
         # kayıplar @touched_topics'e geri alınır, bir sonraki flush noktası dener.
-        def auto_digest_touched!(spawn: true)
+        def auto_digest_touched!(spawn: true, goal_ordinal: nil)
           return false unless @auto_digest && @distiller_enabled
 
           spawn_allowed = spawn && !stopped?
@@ -395,10 +410,11 @@ module Rubik
           return false if topics.empty?
 
           stranded = topics.reject do |topic|
-            _receipt, status = @gate.submit_with_status(topic, spawn: spawn_allowed)
+            _receipt, status = @gate.submit_with_status(topic, spawn: spawn_allowed, goal_ordinal: goal_ordinal)
+            next true if status == :duplicate && Vakanuvis.log_duplicate_digest(@dmesg, topic, goal_ordinal) # F9: sessiz başarı değil
             next true unless status == :full
 
-            Vakanuvis.log_via(@dmesg, :warn, "auto-digest refused for '#{topic}' (gate capacity full) — kept for the next flush point")
+            Vakanuvis.log_via(@dmesg, :warn, "auto-digest refused for '#{topic}' (gate capacity full) — kept for the next goal end or shutdown")
             false
           rescue StandardError => e
             Vakanuvis.log_via(@dmesg, :warn, "auto-digest submit failed for '#{topic}' (#{e.class}: #{e.message})")
@@ -411,6 +427,15 @@ module Rubik
             note += "; #{stranded.size} refused/failed topic(s) kept for the next flush point (warnings above)" unless stranded.empty?
             Vakanuvis.log_via(@dmesg, :warn, note)
           end
+          # Kapalı doğum: kapı :accepted dedi ama damıtıcı hiç doğamaz —
+          # uyarı yoksa topic'ler tüm oturum kuyrukta sessizce birikirdi.
+          if spawn_allowed && @gate.respond_to?(:spawn_allowed?) && !@gate.spawn_allowed?
+            queued = topics - stranded
+            unless queued.empty?
+              note = "auto-digest queued #{queued.size} touched topic(s) but no distiller can run (spawn disabled)"
+              Vakanuvis.log_via(@dmesg, :warn, "#{note} — they will not compile this session: #{queued.join(', ')}")
+            end
+          end
           stranded.empty?
         end
 

data/lib/rubik/storage/vakanuvis/job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rubik
+  module Storage
+    module Vakanuvis
+      module DistillGate
+        # Digest iş sözleşmesinin tek evi (tarama kartı 1, 2026-11-01 — defer #9
+        # kapanışı): kuyrukta iki ayrı Hash literal mint ediliyor, tüketiciler
+        # dört anahtarı [] ile okuyor ve öksüz :goal_id hiçbir mint sitesinde
+        # yazılmıyordu. Job bu şekli tiper: Struct#[] sembol okumasını korur
+        # (mevcut okuma siteleri değişmez), keyword_init mint sitelerini
+        # sözlüğe sabitler, var olmayan anahtar imkânsızlaşır.
+        #
+        # - query: damıtılacak konu sorgusu (toplu işlerde nil)
+        # - target: hedef wiki ref (Vocabulary.wiki_ref) — nil ⇒ toplu derleme;
+        #   nil-target ayırt etme sözleşmesi değişmez, batch onun açık bayrağıdır
+        # - transcript_uris: kaynak disiplinine uyan tamamlanmış transcript URI'leri
+        # - goal_ordinal: goal-end auto-digest taşıyıcısı (Q2, 2026-11-01) — brief
+        #   goal kaydını (annal.goal.<n> note'u) kaynak listesine ekler;
+        #   kapanış ve toplu işlerde nil, satır brief'e hiç girmez
+        Job = Struct.new(:query, :target, :transcript_uris, :batch, :goal_ordinal, keyword_init: true)
+      end
+    end
+  end
+end

data/lib/rubik/storage/vakanuvis.rb

@@ -69,6 +69,17 @@ module Rubik
           existing["links"] == links.to_h { |k, v| [k.to_s, v.to_s] }.sort.to_h &&
           existing["status"] == status.to_s
       end
+
+      # Mükerrer otomatik-damıtım kabulü (issue #351 F9): "already queued"
+      # sessiz başarı sayılmaz — mevcut iş değişmez, bu goal kaydına
+      # bağlanmaz; iz satırı düşer. Dönen true çağrı yerindeki kısa-devre
+      # koşuluna hizmet eder (mükerrer stranded DEĞİLDİR, yeniden kuyruğa
+      # girmez — var olan iş hedefi zaten derliyor).
+      def log_duplicate_digest(dmesg, topic, goal_ordinal)
+        note = goal_ordinal ? "goal record ##{goal_ordinal} not attached; " : ""
+        log_via(dmesg, :warn, "auto-digest duplicate for '#{topic}' — #{note}existing job keeps its own context")
+        true
+      end
     end
   end
 end
@@ -78,6 +89,7 @@ require_relative "vakanuvis/annal_writer"
 require_relative "vakanuvis/memory_steward"
 require_relative "vakanuvis/wiki_skeleton"
 require_relative "vakanuvis/distill_gate"
+require_relative "vakanuvis/job"
 require_relative "vakanuvis/gate"
 require_relative "vakanuvis/harness"
 require_relative "vakanuvis/orientation"

data/lib/rubik/tools/truncator.rb

@@ -5,6 +5,59 @@ module Rubik
     module Truncator
       DEFAULT_MAX_CHARS = 12_000
       DEFAULT_MAX_LINES = 300
+      # The strategy knob's default lives here (arch scan card 5, 2026-11-01):
+      # both orchestrator planes read tools.truncation_strategy with this
+      # fallback — one literal for the whole repo instead of restated copies.
+      DEFAULT_STRATEGY = :head_tail
+      # Known-strategy set (issue #349): a typo'd config value used to die
+      # silently into the head_tail `else` branch in both planes. This set
+      # is the honest frontier — resolve_strategy warns against it, and a
+      # new strategy added to #truncate must register here to be reachable.
+      STRATEGIES = [:head_tail, :head_only, :tail_only].freeze
+
+      class << self
+        # Configured-value resolver for the strategy fetch sites (root
+        # StepExecutor + subagent ToolDispatch + prompt EmergencyCompactor).
+        # nil/false/empty/missing fall back to the default SILENTLY (that
+        # path is correct today); a non-empty value outside STRATEGIES warns
+        # ONCE per distinct knob+value pair, then keeps the default — the
+        # operator "tuning" truncation with a typo must not get
+        # byte-identical old behavior in silence. `key:` names the config
+        # knob in the warn so each caller's message points at its own
+        # setting, and the frontier dedups on the pair: the same typo under
+        # two different knobs must warn twice, or fixing one knob leaves
+        # the other misconfigured in silence.
+        def resolve_strategy(value, key: "tools.truncation_strategy")
+          return DEFAULT_STRATEGY if value.nil? || value == false || value.to_s.strip.empty?
+
+          sym = value.to_s.downcase.to_sym
+          return sym if STRATEGIES.include?(sym)
+
+          warn_unknown_strategy(value, key)
+          DEFAULT_STRATEGY
+        end
+
+        private
+
+        # One-time-per-knob-and-value warn (UI::Theme#paint precedent):
+        # the first bad value speaks, re-occurrences (every tool result
+        # would re-resolve) stay quiet. Warn level, not debug: a config
+        # typo is operator-visible in normal operation. The value is
+        # forced to UTF-8 and scrubbed BEFORE interpolation — scrub alone
+        # is a no-op on BINARY strings — because Log.warn's rescue cannot
+        # reach a message that fails to build, and a binary-encoding
+        # config value must never turn tool results into errors.
+        def warn_unknown_strategy(value, key)
+          shown = value.to_s.dup.force_encoding(Encoding::UTF_8).scrub
+          return unless unknown_strategies.add?([key, shown])
+
+          Rubik::Log.warn(:tools, "#{key}='#{shown}' is not a known strategy (#{STRATEGIES.join('/')}) — using #{DEFAULT_STRATEGY}")
+        end
+
+        def unknown_strategies
+          @unknown_strategies ||= Set.new
+        end
+      end
 
       def self.truncate(text, max_chars: DEFAULT_MAX_CHARS, max_lines: DEFAULT_MAX_LINES, strategy: :head_tail, separator: "\n")
         str = text.to_s

data/lib/rubik/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubik
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubik
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Özgür Ulukır
@@ -267,6 +267,7 @@ files:
 - lib/rubik/benchmark.rb
 - lib/rubik/benchmark/runner.rb
 - lib/rubik/benchmark/synth_repo.rb
+- lib/rubik/benchmark/vakanuvis_adoption.rb
 - lib/rubik/buffer.rb
 - lib/rubik/buffer/apply_contract.rb
 - lib/rubik/buffer/diff.rb
@@ -720,6 +721,7 @@ files:
 - lib/rubik/storage/vakanuvis/distill_gate.rb
 - lib/rubik/storage/vakanuvis/gate.rb
 - lib/rubik/storage/vakanuvis/harness.rb
+- lib/rubik/storage/vakanuvis/job.rb
 - lib/rubik/storage/vakanuvis/memory_steward.rb
 - lib/rubik/storage/vakanuvis/orientation.rb
 - lib/rubik/storage/vakanuvis/service.rb