samagotchi 0.139.1 → 0.140.0

data/docs/plugins.md

@@ -820,6 +820,7 @@ full label, `plugin.rb (bundle my-bundle)`.
 | `ctx.repo_root` | the git checkout holding `cwd`, or nil |
 | `ctx.scratch?` | whether the session is a `chi scratch` one (deleted when it ends) |
 | `ctx.delegate?` | whether the session is a delegate child: a task another session handed over |
+| `ctx.review?` | whether the session is a review session (`chi review`): one its participants read, not the owner's working session |
 | `ctx.frontend` | what runs the session, read now: `:repl` (the REPL, `-p` without `--non-interactive`), `:one_shot` (`-p --non-interactive`: one turn, then exit) or `:worker` (a session worker: the web, an attached TUI). Only a worker's answers reach the web while it runs; a REPL's show there once the session is opened. Until the host sets it (while the plugins load, inside `Engine.new`) it reads `:one_shot`, so read it in hooks and init tasks, not in `register` |
 | `ctx.fork?` | whether the session is a fork (`ctx.sessions.fork`): it has a parent but isn't a delegate child, and started from a conversation, so its first prompt isn't its first user message |
 | `ctx.model` | the model the session runs on now: its resolved ref (`host:id`), right after `/model` too |
@@ -1133,8 +1134,9 @@ ctx.context.attach(url: "https://github.com/acme/app/pull/42", why: "branch feat
 ctx.context.attach(name: "ci", cmd: "bin/ci-status", why: "this branch's CI", every_seconds: 120)
 ctx.context.list  # => [{name:, scope:, why:, hint:, fetched_at:, error:, provider:, summary:}]
 ctx.context.decline(url: "https://github.com/acme/app/pull/42")    # => "pr-42"
-ctx.context.mark_offered("pr-42", "https://github.com/acme/app/pull/42", why: "branch feat/x has open PR #42")
-ctx.context.offered("pr-42")  # => #<data Offer name="pr-42", hint="https://…", why="branch…", at="2026-10-08T…Z">, or nil
+ctx.context.propose(url: "https://github.com/acme/app/pull/42", title: "#42 Make the thing", mentions: ["#42", "feat/x"])
+ctx.context.candidates  # => [#<data Candidate name="pr-42", url="https://…", title="#42 Make the thing", …>]
+ctx.context.withdraw("pr-42")  # => true
 ```
 
 [Attached context](context.md) for the session the plugin runs in: chi runs
@@ -1156,12 +1158,27 @@ gets a note when its text changes.
   `url:`, the name and hint come from the bundle's provider (`name:`
   replaces the name). It returns the name. A source attached already stays
   attached (`chi context rm` removes it).
-- `mark_offered(name, hint, why: nil)` records that the plugin offered a
-  source here (the hint is usually its URL; `why:` is kept for the attach
-  that may follow); `offered(name)` returns that record
-  (`ContextSources::Offer`: `name`, `hint`, `why`, `at`) or nil. A plugin that asks
-  before it attaches uses it so a worker restart doesn't ask again. Neither
-  an attach nor a decline clears it; deleting the session does.
+- `propose(url:, title:, name: nil, describe: nil, mentions: [])` or
+  `propose(name:, cmd:, title:, describe: nil, mentions: [])` records a
+  [candidate](context.md#candidates): a source proposed for this session,
+  not attached. chi attaches it when the session's owner mentions one of its
+  `mentions` in a prompt (the matching rules are in context.md), with the
+  why "you mentioned …". `title` is what a person reads (no probabilities or
+  place facts: "#42 Make the thing"), `describe` more of it. A candidate of
+  that name stays as first proposed (a worker restart proposing again
+  changes nothing). Nothing is proposed (nil) in a review session, for a
+  source attached already (its name or its URL, at any scope), or for one
+  the user removed from the session. A new candidate that an owner prompt
+  already in the session mentions is attached at once: an init task's
+  proposal usually lands while the first turn runs, and that turn's prompt
+  still counts (its note comes with the next turn).
+- `candidates` lists them (`ContextSources::Candidate`: `name`, `url`,
+  `cmd`, `title`, `describe`, `mentions`, `proposed_by`, `at`), by name.
+  Whether one is attached or declined is never stored on it: `chi context
+  ls` and `/context` derive it from the session's sources and declined
+  markers. `withdraw(name)` takes a candidate back (true when there was
+  one); a source attached from it stays attached. Neither an attach nor a
+  decline removes a candidate; deleting the session does.
 - The source is the session's (not the project's), marked
   `added_by: plugin:<bundle>`. It is plugin code, so it isn't asked about as
   the agent's `chi context add --cmd` is.
@@ -1171,11 +1188,11 @@ gets a note when its text changes.
   (nil before any text; chi 0.63.0).
 - Two attaches of one source at once (a double click) both return its
   name.
-- `attach`, `decline` and `mark_offered` raise
+- `attach`, `decline` and `propose` raise
   `Samagotchi::Plugin::AttachedContext::Error` with the reason (no session
   yet, no provider for the URL, a bad name).
 
-The [github-pr bundle](#the-github-pr-bundle) attaches the branch's PR from
+The [github-pr bundle](#the-github-pr-bundle) proposes the branch's PR from
 a quiet `chi.init` task.
 
 ### Context providers in the manifest
@@ -2126,18 +2143,19 @@ bundles:
 chi bundle install github-pr      # in the dev profile; needs gh, logged in
 ```
 
-Attaches the branch's open GitHub pull request to a session as `pr-<n>` when
-its worker starts (not in a scratch session or a delegate child; quietly
-nothing without `gh`, a repository or an open PR), and resolves PR URLs for
-`chi context add`. Its script prints the PR as text
+Proposes the branch's open GitHub pull request to a session as a candidate
+`pr-<n>` when its worker starts (not in a scratch session; quietly nothing
+without `gh`, a repository or an open PR): it is attached once you mention it
+(`#N`, the branch or its URL; [Candidates](context.md#candidates)). It resolves
+PR URLs for `chi context add`. Its script prints the PR as text
 and a summary of what changed in counts, authors and states only; it wakes
 the session for a review requesting changes, checks turning red, or the PR
 merged or closed. In the web, a `path:line` in a worker's answer links to
 that line of the session's PR ([Line links](context.md#line-links); `line_links:
 always` for the REPL and `chi -p` too), and its ref menu offers the file
-here and a "PR diff" action (`event[:refs]`). `auto_attach:
-offer` asks with a card first (`/pr-attach N`, `/pr-decline N`), `off`
-attaches nothing ([Attach, offer or off](context.md#attach-offer-or-off)).
+here and a "PR diff" action (`event[:refs]`). `auto_attach: attach` attaches
+it at once (the old default), `off` does nothing ([Propose, attach or
+off](context.md#propose-attach-or-off)).
 See [Attached context](context.md#github-prs-the-github-pr-bundle).
 
 ## The coordinator bundle

data/lib/samagotchi/bridge/turn_accumulator.rb

@@ -77,7 +77,9 @@ module Samagotchi
       # The turn in progress as conversation messages, for a plugin's
       # ctx.messages mid-turn (plan O1): its prompt (with its images), the
       # model's text so far, and the lines merged into it, in order. Tool
-      # calls and thinking are left out.
+      # calls and thinking are left out. The prompt carries the turn's id,
+      # as the saved one will (OwnerPrompt.message?: a late candidate
+      # proposal matches the running turn's prompt too).
       # @return [Array<Hash>] [] with no turn running
       def current_messages
         @mutex.synchronize { @turn ? self.class.messages_of(@turn) : [] }
@@ -94,6 +96,7 @@ module Samagotchi
         end
         unless turn[:prompt].nil?
           prompt = { role: "user", content: turn[:prompt].to_s, **author_of(turn) }
+          prompt[:turn_id] = turn[:turn_id] if turn[:turn_id]
           prompt[:images] = turn[:images] if turn[:images]
           messages << prompt
         end

data/lib/samagotchi/bundles/dev/manifest.yml

@@ -1,10 +1,10 @@
 ---
 name: dev
-version: 0.7.3
+version: 0.7.4
 scope: system
 description: "Developer tools"
 trust_level: reviewed
-requires_chi: ">= 0.121.0"
+requires_chi: ">= 0.140.0"
 includes:
 - known-names
 - mcp

data/lib/samagotchi/bundles/github-pr/manifest.yml

@@ -1,17 +1,17 @@
 ---
 name: github-pr
-version: 0.5.1
+version: 0.6.0
 scope: system
-description: Attaches the branch's open GitHub pull request to a session as context (and any PR URL with chi context add or the web's "+ URL"); the agent gets a note when reviews, comments, checks or its state change; in the web, a path:line in an answer links to that line of the PR; the auto_attach setting can offer the PR with a card first, or attach nothing
+description: Proposes the branch's open GitHub pull request to a session, attached once you mention it (#N, the branch or its URL), and attaches any PR URL with chi context add or the web's "+ URL"; the agent gets a note when reviews, comments, checks or its state change; in the web, a path:line in an answer links to that line of the PR; the auto_attach setting can attach the PR at once instead, or do nothing
 trust_level: reviewed
-requires_chi: ">= 0.61.0"
+requires_chi: ">= 0.140.0"
 needs:
 - command: gh
   why: reads the pull request
   hint: brew install gh, then gh auth login
 plugin:
   file: plugin.rb
-  sha256: sha256:cfadb7668528302b3631681e570899230b6878c80ccbc87dfb16c80d43dead7b
+  sha256: sha256:558bd4191f28b7c54d4521f55e8514a63568d5e2df5a4937856821fd88de508f
 scripts:
   pr_context.rb: sha256:a883d2780e89c68c0d7b6d5e0fcb22c273f17bb167e79064e0e99db6bd2ee6f0
 context_providers:

data/lib/samagotchi/bundles/github-pr/plugin.rb

@@ -7,12 +7,15 @@ require "time"
 require "tmpdir"
 
 # github-pr: a session on a branch with an open GitHub PR gets the PR
-# attached as context (docs/context.md) when its worker starts: a quiet
-# init task asks git for the branch and gh for its PR, and attaches it
-# through this bundle's provider (manifest context_providers, which also
-# serves `chi context add <PR URL>` and the web's "+ URL"). Nothing for a
-# scratch session or a delegate child (D12), and nothing, quietly, without
-# gh, its login, a repo or an open PR.
+# proposed as a candidate (docs/context.md, Candidates) when its worker
+# starts: a quiet init task asks git for the branch and gh for its PR, and
+# proposes it through this bundle's provider (manifest context_providers,
+# which also serves `chi context add <PR URL>` and the web's "+ URL"),
+# titled "#N <title>", mentioned by "#N", the branch and the URL. chi
+# attaches it once the owner mentions one of them. Nothing for a scratch
+# session, and nothing, quietly, without gh, its login, a repo or an open
+# PR. At a turn's start, more than RELOOK_SECONDS after the last look, it
+# looks again on a thread of its own (a branch switched mid-session).
 #
 # Line links: in the web, a `lib/foo.rb:28` (or `lib/foo.rb:28-34`, in
 # inline code too) in the model's answer links to that line of the PR the
@@ -32,11 +35,9 @@ require "tmpdir"
 # the REPL and -p too (still not for a scratch session).
 #
 # `bundles: github-pr: auto_attach:` says what the init task does with the
-# branch's open PR: `attach` (the default), `offer` (a card with Attach and
-# Not here, which run /pr-attach N and /pr-decline N; nothing attached until
-# a click; offered once per session) or `off` (nothing). In offer mode the
-# offers, their outcomes and each session's first prompt go to
-# <data_dir>/offers.ndjson (OffersLog), to find heuristics later.
+# branch's open PR: `propose` (the default, above), `attach` (attached at
+# once, the old default: not for a delegate child, D12) or `off`
+# (nothing). `offer` (the card it once posted) is read as `propose`.
 class Plugin
   # gh and git each get this long (a network hang must not keep a thread).
   COMMAND_SECONDS = 20
@@ -44,14 +45,12 @@ class Plugin
   GENERATION_CHECK_SECONDS = 30
   # line_links' values: off, a worker's only (the default), every frontend.
   LINE_LINKS_MODES = { false => :off, true => :worker, "always" => :always }.freeze
-  # auto_attach's values (YAML's bare true/false: attach/off).
-  AUTO_ATTACH_MODES = { "attach" => :attach, "offer" => :offer, "off" => :off, true => :attach, false => :off }.freeze
-  # /pr-attach and /pr-decline take a PR number (`42` or `#42`).
-  PR_NUMBER = /\A#?(\d+)\z/
-  # The offer card's line under the PR's title.
-  OFFER_LINE = "Not attached: the agent gets nothing until you attach it."
-  # first_prompt keeps this much of the prompt.
-  FIRST_PROMPT_CHARS = 160
+  # auto_attach's values (YAML's bare true/false: attach/off). `offer`, the
+  # card it once posted, reads as propose (warned once).
+  AUTO_ATTACH_MODES = { "propose" => :propose, "attach" => :attach, "offer" => :propose, "off" => :off, true => :attach,
+                        false => :off }.freeze
+  # A turn's start looks for the branch's PR again after this long.
+  RELOOK_SECONDS = 300
   # A git remote URL's GitHub owner and repo (https, ssh or scp-like).
   REMOTE_REPO = %r{github\.com[:/]([^/\s]+)/([^/\s]+?)(?:\.git)?/?\z}i
 
@@ -59,6 +58,9 @@ class Plugin
     @cache = PrCache.new
     @generation_checked_at = nil
     @warned_mode = false
+    @looked_at = nil
+    @look_mutex = Mutex.new
+    @looking = false
     @warned_line_links = false
     # cwd => the "owner/repo"s (downcased) its git remotes name on
     # github.com, for the worker's life.
@@ -67,7 +69,7 @@ class Plugin
 
   def register(chi)
     chi.init("Looking for this branch's pull request", quiet: true) do |ctx|
-      summary = attach_branch_pr(ctx)
+      summary = look(ctx)
       # Inline (an init task has its own thread), whatever the attach
       # returned (attached already, a child, a scratch session), and after
       # it, so a PR it just attached is warm for the first answer.
@@ -78,13 +80,7 @@ class Plugin
       # The prompt too: messages is the history before this turn, and a
       # delegate child's task is its first prompt.
       kick(ctx, attached_prs(ctx) + PrRef.from_messages(event[:messages], prompt: event[:prompt])) if prefetch?(ctx)
-      log_first_prompt(event, ctx)
-    end
-    chi.command("/pr-attach", "Attach the PR this session was offered: /pr-attach 42", anytime: true) do |args, ctx|
-      offer_command("/pr-attach", args, ctx) { |number, offer| attach_offered(ctx, number, offer) }
-    end
-    chi.command("/pr-decline", "Don't attach the PR this session was offered: /pr-decline 42", anytime: true) do |args, ctx|
-      offer_command("/pr-decline", args, ctx) { |number, offer| decline_offered(ctx, number, offer) }
+      relook(ctx)
     end
     chi.on(:before_generation) { |_event, ctx| check_attached(ctx) }
     # After source-links (90): its links are in the display this one gets.
@@ -94,11 +90,12 @@ class Plugin
   # @return [String] what it did (the init task's summary)
   def attach_branch_pr(ctx)
     return "skipped: a scratch session" if ctx.scratch?
-    return "skipped: a delegate child" if ctx.delegate?
     return "no session yet" unless ctx.session_id
 
     mode = auto_attach_mode(ctx)
     return "auto_attach: off" if mode == :off
+    return "skipped: a delegate child" if mode == :attach && ctx.delegate?
+    return "skipped: a review session" if mode == :propose && ctx.review?
 
     branch = run(ctx, "git", "branch", "--show-current").to_s.strip
     return "not on a branch" if branch.empty?
@@ -109,7 +106,7 @@ class Plugin
 
     name = "pr-#{pr["number"]}"
     return "#{name} is attached already" if ctx.context.list.any? { |source| source[:name] == name || source[:hint] == pr["url"] }
-    return offer_branch_pr(ctx, branch, pr, name) if mode == :offer
+    return propose_branch_pr(ctx, branch, pr, name) if mode == :propose
 
     attached = ctx.context.attach(url: pr["url"], name: name, why: "branch #{branch} has open PR ##{pr["number"]}")
     attached ? "attached #{name}" : "#{name} was removed from this session; not attached again"
@@ -118,19 +115,49 @@ class Plugin
     "no pull request attached"
   end
 
-  # `bundles: github-pr: auto_attach:`, read at each worker start.
-  # @return [Symbol] :attach, :offer or :off; an unknown value is :attach
-  #   (logged once)
+  # `bundles: github-pr: auto_attach:`, read at each look.
+  # @return [Symbol] :propose, :attach or :off; `offer` and an unknown
+  #   value are :propose (logged once)
   def auto_attach_mode(ctx)
     value = ctx.settings["auto_attach"]
-    return :attach if value.nil?
+    return :propose if value.nil?
 
     key = value.is_a?(String) ? value.strip.downcase : value
+    warn_mode(ctx, :pr_auto_attach_offer_is_propose, value) if key == "offer"
     AUTO_ATTACH_MODES.fetch(key) do
-      ctx.log.warn(:pr_auto_attach_unknown, value: value.to_s[0, 40]) unless @warned_mode
-      @warned_mode = true
-      :attach
+      warn_mode(ctx, :pr_auto_attach_unknown, value)
+      :propose
+    end
+  end
+
+  # #attach_branch_pr, remembering when (a turn's start looks again after
+  # RELOOK_SECONDS).
+  def look(ctx)
+    @look_mutex.synchronize { @looked_at = now }
+    attach_branch_pr(ctx)
+  end
+
+  # A turn's start: the branch's PR looked for again, on a thread of its
+  # own (git and gh never hold the turn), when the last look is more than
+  # RELOOK_SECONDS old and none runs. Propose mode only: attach mode
+  # attaches at the worker's start alone, as it always did.
+  def relook(ctx)
+    return if ctx.scratch? || auto_attach_mode(ctx) != :propose
+
+    claimed = @look_mutex.synchronize do
+      next false if @looking || @looked_at.nil? || now - @looked_at < RELOOK_SECONDS
+
+      @looking = true
+    end
+    return unless claimed
+
+    thread = Thread.new do
+      ctx.log.debug(:pr_relooked, summary: look(ctx))
+    ensure
+      @look_mutex.synchronize { @looking = false }
     end
+    thread.report_on_exception = false
+    thread
   end
 
   # The after_turn handler: links the answer's `path:line` refs from the
@@ -224,113 +251,26 @@ class Plugin
     end
   end
 
-  def offer_card_id(number) = "github-pr-offer-#{number}"
-
-  # Offer mode: a card instead of the attach, once per session per PR (a
-  # worker restart finds the offered marker). The marker is written after
-  # the card, so a card that failed leaves none.
-  def offer_branch_pr(ctx, branch, pr, name)
-    return "#{name} was removed from this session; not offered" if ctx.context.declined?(name, url: pr["url"])
-    return "#{name} was offered already" if ctx.context.offered(name)
-
+  # Propose mode: the PR as a candidate; an owner prompt already in the
+  # session that mentions it attaches it at once (ctx.context.propose).
+  def propose_branch_pr(ctx, branch, pr, name)
     number = pr["number"]
-    body = [pr["title"].to_s.gsub(/\s+/, " ").strip, OFFER_LINE].reject(&:empty?).join("\n\n")
-    ctx.card(id: offer_card_id(number), title: "PR ##{number} for branch #{branch}", body: body, level: :info,
-             actions: [{ label: "Attach", command: "/pr-attach #{number}" },
-                       { label: "Not here", command: "/pr-decline #{number}" }])
-    ctx.context.mark_offered(name, pr["url"], why: "branch #{branch} has open PR ##{number}")
-    offers_log(ctx).write("offered", session: ctx.session_id, project_root: project_root(ctx), cwd: ctx.cwd,
-                                     branch: branch, pr: pr["url"], checkout: checkout_kind(ctx), model: ctx.model)
-    "offered #{name}"
-  end
-
-  # /pr-attach and /pr-decline: the PR number and its offer, else the
-  # answer (a usage line, no offer).
-  def offer_command(command, args, ctx)
-    number = args.to_s.strip[PR_NUMBER, 1] or return "usage: #{command} <PR number>, as the offer card names it"
-    number = number.to_i
-    offer = ctx.context.offered("pr-#{number}")
-    return "no offered PR ##{number} here; use `chi context add <PR URL>`" unless offer
-
-    yield number, offer
-  rescue Samagotchi::Plugin::AttachedContext::Error => e
-    "pr-#{number} not changed: #{e.message}"
-  end
-
-  # The user's click: attached as auto-attach would, past a decline, with
-  # the offer's why (no git or gh here).
-  def attach_offered(ctx, number, offer)
-    why = "#{offer.why || "open PR ##{number}"} (attached from the offer)"
-    attached = ctx.context.attach(url: offer.hint, name: offer.name, why: why, force: true)
-    return "#{offer.name} wasn't attached" unless attached
-
-    ctx.card(id: offer_card_id(number), title: "PR ##{number}", body: "Attached #{attached}")
-    offers_log(ctx).write("attached", session: ctx.session_id, pr: offer.hint, seconds: seconds_since(offer))
-    nil
-  end
-
-  # Not for a PR attached here already (a stale card): that is
-  # `chi context rm`'s, and a declined marker would leave it attached.
-  def decline_offered(ctx, number, offer)
-    attached = ctx.context.list.find { |source| source[:name] == offer.name || source[:hint] == offer.hint }
-    return "#{attached[:name]} is attached here; `chi context rm #{attached[:name]}` removes it" if attached
-
-    ctx.context.decline(url: offer.hint, name: offer.name)
-    ctx.card(id: offer_card_id(number), title: "PR ##{number}", body: "Not attached here; + URL attaches it")
-    offers_log(ctx).write("declined", session: ctx.session_id, pr: offer.hint, seconds: seconds_since(offer))
-    nil
-  end
-
-  def seconds_since(offer)
-    (Time.now - Time.iso8601(offer.at.to_s)).round
-  rescue ArgumentError
-    nil
+    title = "##{number} #{pr["title"].to_s.gsub(/\s+/, " ").strip}".strip
+    proposed = ctx.context.propose(url: pr["url"], name: name, title: title, mentions: ["##{number}", branch, pr["url"]])
+    proposed ? "proposed #{name}" : "#{name} was removed from this session; not proposed"
   end
 
-  # Offer mode: every session's first prompt (offered or not; a web chat's
-  # first turn starts before the init task's gh returns), joined to the
-  # offers by session at analysis time. First = no user message yet (a
-  # context note may be in messages already); a fork starts from its
-  # parent's conversation, user messages and all, so its first is the one
-  # the log has no first_prompt row for yet.
-  def log_first_prompt(event, ctx)
-    return if event[:prompt].nil? || auto_attach_mode(ctx) != :offer
-    return if ctx.scratch? || ctx.session_id.nil?
-
-    log = offers_log(ctx)
-    if Array(event[:messages]).any? { |message| message_role(message) == "user" }
-      return unless ctx.fork? && !log.first_prompt?(ctx.session_id)
-    elsif ctx.delegate?
-      return
-    end
-    log.write("first_prompt", session: ctx.session_id, prompt: event[:prompt].to_s[0, FIRST_PROMPT_CHARS])
-  rescue StandardError => e
-    ctx.log.debug(:pr_offers_log_failed, error: e.class.name)
+  def warn_mode(ctx, event, value)
+    ctx.log.warn(event, value: value.to_s[0, 40]) unless @warned_mode
+    @warned_mode = true
   end
 
-  def message_role(message)
-    return nil unless message.is_a?(Hash)
-
-    (message.key?(:role) ? message[:role] : message["role"]).to_s
-  end
-
-  def offers_log(ctx) = OffersLog.new(File.join(ctx.data_dir, OffersLog::FILE), ctx.log)
-
   def project_root(ctx)
     ctx.repo_root
   rescue StandardError
     nil
   end
 
-  # "main" for the main checkout, "worktree" for a linked one (its git dir
-  # isn't the common one), nil outside a repo.
-  def checkout_kind(ctx)
-    dirs = run(ctx, "git", "rev-parse", "--path-format=absolute", "--git-dir", "--git-common-dir").to_s.split("\n")
-    return nil unless dirs.size == 2
-
-    dirs[0] == dirs[1] ? "main" : "worktree"
-  end
-
   def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
   # #refresh on its own thread (a raw one, docs/plugins.md), when there is
@@ -413,50 +353,6 @@ class Plugin
   end
 end
 
-# <data_dir>/offers.ndjson: one JSON object a line, {event:, ts:, …},
-# private to the user (0600: it holds prompts). Every worker shares it, so
-# each write holds offers.ndjson.lock (flock) around the size check, the
-# rotation and the append; over MAX_BYTES the file becomes
-# offers.ndjson.1 (one old file kept). A failure is logged at debug: the
-# log never breaks an attach.
-class OffersLog
-  FILE = "offers.ndjson"
-  MAX_BYTES = 1024 * 1024
-  LINE_MAX_BYTES = 4000
-  MODE = 0o600
-
-  def initialize(path, log)
-    @path = path
-    @log = log
-  end
-
-  def write(event, **fields)
-    line = "#{JSON.generate({ event: event, ts: Time.now.utc.iso8601 }.merge(fields))}\n"
-    return @log.debug(:pr_offers_line_too_long, event: event) if line.bytesize > LINE_MAX_BYTES
-
-    File.open("#{@path}.lock", File::RDWR | File::CREAT, MODE) do |lock|
-      lock.flock(File::LOCK_EX)
-      File.rename(@path, "#{@path}.1") if File.size?(@path).to_i > MAX_BYTES
-      File.open(@path, File::WRONLY | File::APPEND | File::CREAT, MODE) { |file| file.write(line) }
-    end
-    nil
-  rescue StandardError => e
-    @log.debug(:pr_offers_log_failed, error: e.class.name)
-    nil
-  end
-
-  # Whether the log (or its old file) has session +id+'s first_prompt row.
-  def first_prompt?(id)
-    [@path, "#{@path}.1"].any? do |path|
-      File.exist?(path) && File.foreach(path).any? do |line|
-        line.include?(%("session":#{JSON.generate(id)})) && JSON.parse(line)["event"] == "first_prompt"
-      rescue JSON::ParserError
-        false
-      end
-    end
-  end
-end
-
 # A GitHub pull request, by its URL.
 PrRef = Data.define(:owner, :repo, :number)
 

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.139.1
+version: 0.140.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/config.rb

@@ -217,6 +217,14 @@ module Samagotchi
       # counted here); then they wait as notes. 0: a peer source
       # wakes like any other (once per 10 minutes, the guard line).
       Entry.new(key: "context.peer_turns",       yaml_path: %w[context peer_turns],       type: :integer, default: 3,               expose: %i[env config cli], lifecycle: :next_matching_turn_display_poll_write),
+      # The candidate judge (ContextJudge): off (no conversation text goes to a System 1 host); audit (asks and logs
+      # context_candidates.jsonl, attaches nothing); on (ContextCandidateChoice: p ≥ threshold attaches quietly,
+      # offer_threshold ≤ p < threshold shows one card). Its host and model are guardrails.system_one.host/model.
+      # reask_after_turns: the owner prompts after a judged ask before its one re-ask.
+      Entry.new(key: "context.candidates.mode",  yaml_path: %w[context candidates mode],  type: :enum,   default: "off", expose: %i[config], enum_values: %w[off audit on], lifecycle: :next_matching_turn_display_poll_write),
+      Entry.new(key: "context.candidates.threshold", yaml_path: %w[context candidates threshold], type: :float, default: 0.8, expose: %i[config], lifecycle: :next_matching_turn_display_poll_write),
+      Entry.new(key: "context.candidates.offer_threshold", yaml_path: %w[context candidates offer_threshold], type: :float, default: 0.6, expose: %i[config], lifecycle: :next_matching_turn_display_poll_write),
+      Entry.new(key: "context.candidates.reask_after_turns", yaml_path: %w[context candidates reask_after_turns], type: :integer, default: 3, expose: %i[config], lifecycle: :next_matching_turn_display_poll_write),
 
       # What the model is sent of the conversation (LLMContextStrategy, LLMContextView): none, or a list of layers
       # (stale, forget; "|"-separated or a YAML list); forget (the model's forget_outputs) is experimental.