rubik 0.4.2 → 0.6.0

data/lib/rubik/prompt/doctrine.rb

@@ -221,14 +221,15 @@ module Rubik
       def rule_nine_body(active_tools: nil, plan_mode: false)
         return "Keep the repository worktree free of agent workfiles, scratch notes, and temporary artifacts." if plan_mode
 
+        vakanuvis_on = tool_active?("vakanuvis", active_tools)
         storage_part = if tool_active?("storage", active_tools)
-                         Rubik::Prompt::ToolTeachings.teaching_for("storage")
+                         Rubik::Prompt::ToolTeachings.teaching_for("storage", vakanuvis_active: vakanuvis_on)
                        else
                          "Keep the repository worktree free of scattered agent workfiles; read any existing " \
                            "`rubik://storage/<type>/<id>` entities via `read_file` when a store is wired."
                        end
         parts = [storage_part]
-        parts << Rubik::Prompt::ToolTeachings.teaching_for("vakanuvis") if tool_active?("vakanuvis", active_tools)
+        parts << Rubik::Prompt::ToolTeachings.teaching_for("vakanuvis") if vakanuvis_on
         parts << Rubik::Prompt::ToolTeachings.teaching_for("show_file") if tool_active?("show_file", active_tools)
         parts << "Subagent transcripts are indexed automatically as `transcript` entities (alias `subagent-<storage-id>`) " \
                  "and are readable live or persisted via the canonical `rubik://subagent/<storage-id>/transcript` reference — " \
@@ -244,14 +245,10 @@ module Rubik
         if storage_on && vakanuvis_on
           "Persist pipeline knowledge in the central storage (`storage` tool): the decomposed plan, review findings, " \
             "and the final goal record — link stages with entity ids (`links: {\"goal\": \"goal.N.<hash16>\"}`) so the " \
-            "audit trail survives the session. Per-stage MEMORY notes go through the chronicler instead: " \
-            "`vakanuvis(action: 'record', topic: '...', body: '...')` mints the `mem.` ref, upserts and supersedes — " \
-            "never write memory with raw storage puts when `vakanuvis` is available " \
-            "(fall back to `storage` `put` only when `vakanuvis` is unavailable); re-enter prior context with " \
-            "`vakanuvis(action: 'recall', query: '...')` (also after compaction). Keep the repository worktree free of " \
-            "agent workfiles. Transcripts of finished " \
-            "subagents are indexed automatically (searchable via `storage` action 'search') and persist after the " \
-            "subagent is reaped."
+            "audit trail survives the session. Route durable memory through the chronicler (`vakanuvis` record/recall; " \
+            "see rule 9), never through raw storage puts. Keep the repository worktree free of agent workfiles. " \
+            "Transcripts of finished subagents are indexed automatically (searchable via `storage` action 'search') " \
+            "and persist after the subagent is reaped."
         elsif storage_on
           "Persist pipeline knowledge in the central storage (`storage` tool): the decomposed plan, review findings, " \
             "and the final goal record — link stages with entity ids (`links: {\"goal\": \"goal.N.<hash16>\"}`) so the " \
@@ -259,11 +256,9 @@ module Rubik
             "finished subagents are indexed automatically (searchable via `storage` action 'search') and persist after " \
             "the subagent is reaped."
         elsif vakanuvis_on
-          "Persist durable per-stage MEMORY notes through the chronicler: `vakanuvis(action: 'record', topic: '...', " \
-            "body: '...')` mints the `mem.` ref, upserts and supersedes; re-enter prior context with " \
-            "`vakanuvis(action: 'recall', query: '...')` (also after compaction). Keep the repository worktree free of " \
-            "agent workfiles. Transcripts of finished subagents remain readable via `rubik://subagent/<storage-id>/transcript` " \
-            "after the subagent is reaped."
+          "Route durable memory through the chronicler (`vakanuvis` record/recall; see rule 9). Keep the repository " \
+            "worktree free of agent workfiles. Transcripts of finished subagents remain readable via " \
+            "`rubik://subagent/<storage-id>/transcript` after the subagent is reaped."
         else
           "Keep the repository worktree free of agent workfiles. Transcripts of finished subagents remain readable via " \
             "`rubik://subagent/<storage-id>/transcript` after the subagent is reaped."

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/prompt/tool_teachings.rb

@@ -2,21 +2,23 @@
 
 module Rubik
   module Prompt
-    # Tool teachings keyed by canonical tool name (architecture review
-    # 2026-10-01, candidate 1): the sentences that teach HOW a specific tool
-    # is used live here, one key per tool, instead of being embedded unnamed
-    # in Doctrine.operational_rules_xml's heredoc. Identity (the tool) lives in
-    # its Tools::Declaration; prose (the presentation) lives here — a prompt
-    # layer concern. test_tool_teachings welds the two: every key must
-    # resolve to a declared (Catalog) tool, so a rename that forgets the
-    # prompt fails the suite.
-    #
-    # The strings are interpolated into the operational rules HEREDOC at the
-    # same positions they originally occupied — the rendered rules are
-    # byte-identical (pinned by the substring tests in
-    # test_structured_context_builder, test_agent_command_contract,
-    # test_buffer_apply_conflict, test_repl_tool_separation_and_guardrails).
+    # Tool teachings keyed by canonical tool name (architecture review 2026-10-01, candidate 1):
+    # the sentences that teach HOW a specific tool is used live here, one key per tool.
+    # Identity lives in its Tools::Declaration; prose lives here — a prompt layer concern.
+    # test_tool_teachings welds the two: every key must resolve to a declared Catalog tool.
     module ToolTeachings
+      STORAGE_BASE =
+        "Persist agent workfiles — goals, plans, reviews, and work notes — in the central " \
+        "`storage` database (`storage` tool: put/get/list/search/set_ref/delete), NOT as scattered files in " \
+        "the repository worktree. Read, list, and search all entity types (`goal`, `plan`, `memory`, `wiki`, " \
+        "`transcript`, `review`, `note`) via `storage` or `read_file(path: 'rubik://storage/<type>/<id>')` " \
+        "(browse with `rubik://storage/index` and `rubik://storage/<type>` listings)."
+
+      STORAGE_FALLBACK =
+        "#{STORAGE_BASE[0...-1]}; write durable `memory` cards and compiled `wiki` pages through direct " \
+        "`storage` `put` on `memory`/`wiki` (reserving direct `storage` `put` on `memory`/`wiki` for sessions " \
+        "where `vakanuvis` is unavailable).".freeze
+
       TEACHINGS = {
         "replace_file_content" =>
           "For modifying existing files, prefer `replace_file_content` with `path`, exact verbatim `target_content`, " \
@@ -35,15 +37,7 @@ module Rubik
           "params_schema: { type: 'object', properties: { ... }, required: [...] }, code: '->(args) { ... }')` " \
           "(always provide `params_schema` when the handler reads arguments from `args`; omit it or pass an empty " \
           "`{ type: 'object', properties: {} }` schema only for tools that take no arguments).",
-        "storage" =>
-          "Persist agent workfiles — goals, plans, reviews, and work notes — in the central " \
-          "`storage` database (`storage` tool: put/get/list/search/set_ref/delete), NOT as scattered files in " \
-          "the repository worktree. Read, list, and search all entity types (`goal`, `plan`, `memory`, `wiki`, " \
-          "`transcript`, `review`, `note`) via `storage` or `read_file(path: 'rubik://storage/<type>/<id>')` " \
-          "(browse with `rubik://storage/index` and `rubik://storage/<type>` listings); write durable `memory` " \
-          "cards and compiled `wiki` pages through `vakanuvis` (`record` / `digest`) whenever `vakanuvis` is in " \
-          "your toolbelt, reserving direct `storage` `put` on `memory`/`wiki` for sessions where `vakanuvis` is " \
-          "unavailable.",
+        "storage" => STORAGE_BASE,
         "run_command" =>
           "GitHub facts must be verified, not assumed: after `gh pr merge` (which can succeed with EMPTY output) " \
           "confirm the merge with `gh pr view <number> --json state`; `mergeable: UNKNOWN` right after a push means " \
@@ -57,17 +51,13 @@ module Rubik
           "while your context stays lean; only fall back to read_file when YOU must reason about the content.",
         "vakanuvis" =>
           "The background chronicler keeps compiled knowledge (memory cards, wiki pages) in rubik://storage. " \
-          "At task start — and again after any compaction — ask it with `vakanuvis(action: 'recall', query: '...')` " \
-          "instead of pre-loading pages: it returns a deterministic digest plus rubik:// source links. When " \
-          "dispatching a subagent, paste the relevant recall digest (or its rubik:// link) into the task brief. " \
-          "At the end of a task, persist only the durable knowledge with `vakanuvis(action: 'record', topic: '...', " \
-          "body: '...')` — memory writes go through record (ref minting, upsert, supersede come free), never " \
-          "through raw storage puts when `vakanuvis` is available. Recall is keyword-AND over card/page text, so END " \
-          "every recorded body and digest query with its own vocabulary: include a `Keywords:` line listing 5-10 " \
-          "synonyms in BOTH working languages (e.g. TR + EN) — a Turkish query cannot otherwise find an English page. " \
-          "If recall is too shallow, queue `vakanuvis(action: 'digest', query: '...')`: it returns a deterministic " \
-          "receipt and compiles the wiki page asynchronously. Make the session close a standard digest point: review " \
-          "the session's new cards, queue one digest per open topic, and let the home index refresh.",
+          "At task start, ask it with `vakanuvis(action: 'recall', query: '...')`: it returns a deterministic " \
+          "digest plus rubik:// source links. Recall is keyword-AND over card/page text: use 2-3 core terms. " \
+          "If the result is empty, retry once with other-language synonyms. When dispatching a subagent, paste " \
+          "the relevant recall digest (or its rubik:// link) into the task brief. At the end of a task, persist " \
+          "durable conclusions with `vakanuvis(action: 'record', topic: '...', body: '...')` — memory writes go " \
+          "through record (ref minting, upsert, supersede come free), never through raw storage puts. End the body " \
+          "with a `Keywords:` line (TR+EN) if you can; it is auto-extracted otherwise.",
         "prune_context" =>
           "When long sessions leave stale exploration and superseded tool output weighing on the ROOT window, " \
           "check `prune_context(action: 'status')` (window estimate vs ceiling, staged plan state) and force a " \
@@ -79,7 +69,11 @@ module Rubik
 
       module_function
 
-      def teaching_for(tool_name) = TEACHINGS[tool_name.to_s]
+      def teaching_for(tool_name, vakanuvis_active: true)
+        return vakanuvis_active ? STORAGE_BASE : STORAGE_FALLBACK if tool_name.to_s == "storage"
+
+        TEACHINGS[tool_name.to_s]
+      end
     end
   end
 end

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

@@ -97,6 +97,7 @@ module Rubik
             config: context_cfg,
             force: true
           )
+          Rubik::Storage::Vakanuvis::Orientation.inject_after_compaction!(ctx.conversation_history, ctx.runtime_manager, config: ctx.config)
           after_tokens = Rubik::Prompt::TokenEstimator.estimate_history(ctx.conversation_history)
           delta = before_tokens - after_tokens
           ctx.out.puts "Context compaction completed: #{before_tokens} -> #{after_tokens} tokens (reduced #{delta} tokens)."

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/commands/system.rb

@@ -57,11 +57,13 @@ module Rubik
 
           shell.register_command("clear", description: "Clear conversation history / dialogue turns") do |_args, ctx|
             ctx.conversation_history.clear
+            Rubik::Storage::Vakanuvis::Orientation.reset_session!(ctx.runtime_manager)
             ctx.out.puts "Conversation context cleared. Starting fresh topic."
           end
 
           shell.register_command("reset", description: "Reset conversation history and in-memory dialogue turns") do |_args, ctx|
             ctx.conversation_history.clear
+            Rubik::Storage::Vakanuvis::Orientation.reset_session!(ctx.runtime_manager)
             ctx.out.puts "Conversation context reset. Starting fresh topic."
           end
 

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/repl/turn_recorder.rb

@@ -191,6 +191,8 @@ module Rubik
       def apply_staged_prune_plan!
         return if @replaying
 
+        Rubik::Storage::Vakanuvis::Orientation.inject_session_start!(@conversation_history, @runtime_manager, config: @config) if @conversation_history.empty?
+
         harness = Rubik::Coeffects.get(@runtime_manager&.context, Rubik::Coeffects::PRUNER)
         return unless harness
 
@@ -198,6 +200,7 @@ module Rubik
         return unless new_window
 
         @conversation_history = new_window
+        Rubik::Storage::Vakanuvis::Orientation.inject_after_compaction!(@conversation_history, @runtime_manager, config: @config)
         line = "[Pruner] Applied staged plan: dropped #{receipt[:dropped]} unit(s), " \
                "summarized #{receipt[:summarized]} (#{receipt[:skipped_stale]} stale op(s) skipped) — " \
                "window ~#{receipt[:before_tokens]} -> ~#{receipt[:after_tokens]} tokens."

data/lib/rubik/security/redactor.rb

@@ -38,16 +38,20 @@ module Rubik
         return text unless text.is_a?(String)
         return text if text.empty?
 
-        # scrub: redact ham geçmişe (tool çıktısı, prompt) dokunur — geçersiz
-        # UTF-8 gsub!'ı ArgumentError ile düşürür; total olmak maskenin
-        # kendisi bir arıza kaynağı olmasın demektir.
-        result = text.valid_encoding? ? text.dup : text.scrub
+        # PERF: Fast-path for valid encoding strings: test QUICK_CHECK_REGEX
+        # directly on input text before calling dup or scrub. This short-circuits
+        # clean strings without allocating extra intermediate string copies or
+        # running scrub/gsub passes (~2.7x speedup, ~50% fewer allocations).
+        if text.valid_encoding?
+          return text.dup unless text.match?(QUICK_CHECK_REGEX)
 
-        # PERF: kısa devre — sır tetikleyicisi yoksa 11 gsub turu atlanır.
-        # Tetik testi scrub'lanmış sonuç üstünde yapılır: match? ham geçersiz
-        # UTF-8'de ArgumentError düşürür; scrub sonrası metin hep geçerlidir
-        # ve desenler zaten bu metne uygulanıyordu, dolayısıyla eşdeğerdir.
-        return result unless result.match?(QUICK_CHECK_REGEX)
+          result = text.dup
+        else
+          # Fall back safely for invalid UTF-8 / binary strings: scrub first so
+          # match? and gsub! do not raise ArgumentError.
+          result = text.scrub
+          return result unless result.match?(QUICK_CHECK_REGEX)
+        end
 
         # Keep replacement order: masking one credential can expose a word
         # boundary needed to recognize the next (for example, a bearer token).

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

@@ -54,8 +54,13 @@ module Rubik
           # hemen ardından doğum denemesi AYRI bir @lock penceresinde
           # (iki fazlı — tek büyük kritik bölüm İÇİNE ALMA). Doğum
           # başarısızsa iş kuyrukta kalır: yarım durum birikmez.
-          # Dönen makbuz dizgesi bayt-bayt eski Harness#digest çıktısıdır.
-          def submit(query)
+          # Dönen makbuz dizgesi bayt-bayt eski Harness#digest çıktısıdır;
+          # 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).
+          # 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.
@@ -63,23 +68,22 @@ 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: '...')."
-            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."
-            end
+            return [DistillGate.duplicate_receipt(query, target), admission] if admission == :duplicate
 
-            spawned = spawn_job!(batch: false)
-            DistillGate.receipt(query: query, target: target, spawned: !spawned.nil?)
+            return [DistillGate.full_receipt(target, @max_digest_jobs), admission] if admission == :full
+
+            spawned = spawn ? spawn_job!(batch: false) : nil
+            # 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]
+
           # ---- Seam 2: worker thread'i (Harness#handle_subagent çağırır) ---
 
           # Ham subagent tamamlanma olayı. İş sicilden @lock altında
@@ -145,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
@@ -214,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)