samagotchi 0.61.0 → 0.63.0

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

@@ -20,8 +20,10 @@ require "tmpdir"
 # hunk, else the file at the PR's head. The PRs are the session's attached
 # github-pr sources and the PR URLs in the user's messages (a delegate
 # child's task is its first one). Display only (event[:present]): the
-# model's text stays as it was. The after_turn hook links from a per-PR
-# cache and never runs gh (the web holds the answer until the hooks are
+# model's text stays as it was. Each linked ref is also a file ref on the
+# answer (event[:refs], chi 0.61.0): the file in this checkout, with a "PR
+# diff" (or "File at head") action the web's ref menu offers. The
+# after_turn hook links from a per-PR cache and never runs gh (the web holds the answer until the hooks are
 # done); before_turn, before_generation and the init task fill the cache
 # off the turn's thread (`gh api`), in a session worker only: the REPL and
 # -p --non-interactive show no web page while they run (ctx.frontend; a chi
@@ -50,12 +52,17 @@ class Plugin
   OFFER_LINE = "Not attached: the agent gets nothing until you attach it."
   # first_prompt keeps this much of the prompt.
   FIRST_PROMPT_CHARS = 160
+  # A git remote URL's GitHub owner and repo (https, ssh or scp-like).
+  REMOTE_REPO = %r{github\.com[:/]([^/\s]+)/([^/\s]+?)(?:\.git)?/?\z}i
 
   def initialize
     @cache = PrCache.new
     @generation_checked_at = nil
     @warned_mode = false
     @warned_line_links = false
+    # cwd => the "owner/repo"s (downcased) its git remotes name on
+    # github.com, for the worker's life.
+    @checkout_repos = {}
   end
 
   def register(chi)
@@ -138,7 +145,39 @@ class Plugin
     cached = prs.filter_map { |pr| (data = @cache[pr]) && [pr, data] }
     return if cached.empty?
 
-    event[:present].call { |display| LineLinker.new(cached).link(display) }
+    linker = LineLinker.new(cached)
+    event[:present].call { |display| linker.link(display) }
+    add_refs(event[:refs], linker.found, ctx) unless linker.found.empty?
+  end
+
+  # Each linked `path:line` as a file ref on the answer (event[:refs]): its
+  # target the file in this checkout (its root + the PR path), its action
+  # the link's URL, named by what it opens. Only for a PR of this
+  # checkout's repo (one of its git remotes names it): another project's PR
+  # has its files elsewhere, so its links stay links.
+  def add_refs(refs, found, ctx)
+    return unless refs
+
+    root = project_root(ctx)
+    return unless root
+
+    repos = checkout_repos(ctx)
+    found.each do |hit|
+      next unless repos.include?(hit[:repo].downcase)
+
+      action = hit[:diff] ? { id: "pr_diff", label: "PR diff", url: hit[:url] } : { id: "blob", label: "File at #{hit[:at]}", url: hit[:url] }
+      refs.call(match: hit[:match], kind: "file", label: nil, actions: [action],
+                target: { path: File.join(root, hit[:path]), line: hit[:line], end_line: hit[:end_line] })
+    end
+  end
+
+  # The GitHub "owner/repo"s (downcased) the checkout's git remotes name
+  # (`git remote -v`: a fork's upstream too), asked once per cwd.
+  def checkout_repos(ctx)
+    @checkout_repos[ctx.cwd] ||= run(ctx, "git", "remote", "-v").to_s.each_line.filter_map do |line|
+      match = line.split(/\s+/)[1].to_s.match(REMOTE_REPO)
+      "#{match[1]}/#{match[2]}".downcase if match
+    end.uniq
   end
 
   # Fetches the PRs in +prs+ whose cache entry is missing or old, on this
@@ -580,9 +619,17 @@ class LineLinker
     nil
   end
 
+  # The refs the last #link linked, in order: {match:, url:, diff:, at:,
+  # repo:, path:, line:, end_line:} (+match+ the ref's text, inline code's
+  # without its backticks; +diff+ true for a PR diff URL, else +at+ "head"
+  # or "base", the sha of the file's URL; +repo+ the PR's "owner/repo";
+  # +path+ the PR's path of the file).
+  attr_reader :found
+
   # @param prs [Array<Array(PrRef, PrData)>]
   def initialize(prs)
     @prs = prs
+    @found = []
   end
 
   # +text+ with each ref that names exactly one PR's file as a markdown
@@ -591,8 +638,10 @@ class LineLinker
     head = text[0, MAX_SCAN]
     out = +""
     pos = 0
-    hits(head).each do |start, finish, url|
-      out << head[pos...start] << "[#{head[start...finish]}](#{url})"
+    @found = []
+    hits(head).each do |start, finish, hit|
+      out << head[pos...start] << "[#{head[start...finish]}](#{hit[:url]})"
+      @found << hit
       pos = finish
     end
     return text if pos.zero?
@@ -602,7 +651,11 @@ class LineLinker
 
   # The URL for +path+'s lines +from+..+to+ (+to+ nil: one line), or nil:
   # no PR has the file, or more than one does.
-  def url_for(path, from, to = nil)
+  def url_for(path, from, to = nil) = line_for(path, from, to)&.fetch(:url)
+
+  # {url:, diff:, path:, line:, end_line:} for +path+'s lines (see #url_for),
+  # or nil.
+  def line_for(path, from, to = nil)
     found = @prs.filter_map do |pr, data|
       file = resolve(data.files, path)
       [pr, data, file] if file
@@ -614,7 +667,7 @@ class LineLinker
 
   private
 
-  # [start, finish, url] for each ref to link, by offset.
+  # [start, finish, hit] for each ref to link, by offset (+hit+ as #found's).
   def hits(text)
     fences = fenced_blocks(text)
     skipped = fences + spans(text, URL_SPAN) + spans(text, MARKDOWN_LINK)
@@ -624,7 +677,7 @@ class LineLinker
       next if inside_any?(skipped, start, finish)
 
       match = inner.strip.match(REF_ALONE) or next
-      url = ref_url(match) and found << [start, finish, url]
+      hit = ref_line(match) and found << [start, finish, hit.merge(match: match[0])]
     end
     text.scan(REF) do
       match = Regexp.last_match
@@ -632,20 +685,20 @@ class LineLinker
       finish = match.end(0)
       next if inside_any?(skipped, start, finish) || inside_any?(code, start, finish)
 
-      url = ref_url(match) and found << [start, finish, url]
+      hit = ref_line(match) and found << [start, finish, hit.merge(match: match[0])]
     end
     found.sort_by(&:first)
   end
 
   # A path has a `/` or an extension (`10:30` is a time, `host:8080` a port).
-  def ref_url(match)
+  def ref_line(match)
     path = match[:path]
     return nil unless path.include?("/") || path.match?(/\.[A-Za-z0-9]+\z/)
 
     from = match[:from].to_i
     to = match[:to]&.to_i
     to = nil if to && to <= from
-    from.zero? ? nil : url_for(path, from, to)
+    from.zero? ? nil : line_for(path, from, to)
   end
 
   # The PR file +path+ names: the path (or a rename's old one) exactly,
@@ -687,18 +740,21 @@ class LineLinker
 
   # The PR's Files changed anchor when the lines are inside one hunk (the
   # new side; a removed file's old side), else the file at the PR's head
-  # (a removed one: at its base), which has every line.
+  # (a removed one: at its base), which has every line. As #line_for's
+  # hash.
   def line_url(pr, data, file, from, to)
     last = to || from
+    lines = { path: file.path, line: from, end_line: to, repo: "#{pr.owner}/#{pr.repo}" }
     hunks, side = file.removed? ? [file.old_hunks, "L"] : [file.new_hunks, "R"]
     if hunks.any? { |hunk| hunk.cover?(from) && hunk.cover?(last) }
       anchor = "#{side}#{from}#{"-#{side}#{to}" if to}"
-      return "#{pr.url}/files#diff-#{Digest::SHA256.hexdigest(file.path)}#{anchor}"
+      return { url: "#{pr.url}/files#diff-#{Digest::SHA256.hexdigest(file.path)}#{anchor}", diff: true, at: nil, **lines }
     end
 
     sha = file.removed? ? data.base_sha : data.head_sha
     path = file.path.split("/").map { |segment| segment.gsub(/[^\w.~-]/) { |c| c.bytes.map { |b| format("%%%02X", b) }.join } }
-    "https://github.com/#{pr.owner}/#{pr.repo}/blob/#{sha}/#{path.join("/")}#L#{from}#{"-L#{to}" if to}"
+    { url: "https://github.com/#{pr.owner}/#{pr.repo}/blob/#{sha}/#{path.join("/")}#L#{from}#{"-L#{to}" if to}", diff: false,
+      at: file.removed? ? "base" : "head", **lines }
   end
 
   # [start, finish, inner] for each inline code span outside +fences+: a

data/lib/samagotchi/bundles/loop-guard/manifest.yml

@@ -1,10 +1,10 @@
 ---
 name: loop-guard
-version: 0.3.7
+version: 0.3.8
 scope: system
 description: "Breaks loops: the same tool call with the same result again and again in one turn is denied with advice (after a few denies the turn stops with a card), and thinking that repeats itself while it streams is cut and the model asked again"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:e8c31f608f7cef5d605285efcc40ca32efd7fd60c862a39480b9edf61df56acc
+  sha256: sha256:334c45355493b35904a27a61d8cd12e4cce157fa0eff233918c92cf2961cba57
 requires_chi: ">= 0.6.0"

data/lib/samagotchi/bundles/loop-guard/plugin.rb

@@ -297,7 +297,7 @@ class Plugin
   def register(chi)
     chi.on(:before_turn) { |_event| reset }
     chi.on(:before_tool_call) { |event, ctx| before(event, ctx) }
-    chi.on(:after_tool_call) { |event| after(event) }
+    chi.on(:after_tool_call) { |event, ctx| after(event, ctx) }
     return unless @thinking["watch"]
 
     chi.on(:before_generation) do |_event|
@@ -377,6 +377,7 @@ class Plugin
     @warned = {}       # key => true once notified this turn
     @denials = 0
     @pending = nil
+    @stop_card = nil   # the stop's card, posted after the denied call
     @thinking_loops = 0
     @good_steps = 0
     @watch = nil
@@ -412,7 +413,8 @@ class Plugin
   # A call's result, paired with the before_tool_call that keyed it. A call
   # that was denied (by us or another voter) ran nothing: no result, or the
   # deny text would become the key's result and the next call would pass.
-  def after(event)
+  def after(event, ctx)
+    post_stop_card(ctx)
     pending = @pending
     @pending = nil
     return unless pending && event[:tool].to_s == pending[:key].first
@@ -426,16 +428,25 @@ class Plugin
     @previews[key] = preview(output)
   end
 
+  # The turn stops now; its card waits for the denied call's
+  # after_tool_call (#post_stop_card), so a UI that prints events in order
+  # shows it under that call's row, not before it.
   def stop(ctx)
     ctx.stop_turn("the model kept repeating the same calls")
     repeated = @attempts.select { |key, n| n > 1 && @last_result[key] && @results[[key, @last_result[key]]] >= @deny_after }
     lines = repeated.map do |key, n|
       "- `#{short_key(key)}`: #{n} times, the same result each time (#{@previews[key]})"
     end
-    ctx.card(title: "loop-guard stopped the turn",
-             body: "The model kept repeating these calls:\n\n#{lines.join("\n")}\n\n" \
-                   "Tell it what to try instead, or where to look.",
-             level: :warn)
+    @stop_card = { title: "loop-guard stopped the turn",
+                   body: "The model kept repeating these calls:\n\n#{lines.join("\n")}\n\n" \
+                         "Tell it what to try instead, or where to look.",
+                   level: :warn }
+  end
+
+  def post_stop_card(ctx)
+    card = @stop_card
+    @stop_card = nil
+    ctx.card(**card) if card
   end
 
   def warn(ctx, key, what)

data/lib/samagotchi/bundles/slow-commands/manifest.yml

@@ -1,12 +1,12 @@
 ---
 name: slow-commands
-version: 0.2.0
+version: 0.2.1
 scope: system
 description: "Remembers commands that ran past the execute limit in a project; the next identical execute is denied once a turn with advice to run it with task_create and task_wait; /slow-commands lists and forgets them"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:bf2cfccbcadedcd85ea0b53f2d263c8729e14ed8cf310bca4a56affe50181292
+  sha256: sha256:cc8b9829ae77565d8d47969377e91124cf4c785164e417d3d323daeec1295269
 # Execute::HANDED_OVER, read when the plugin loads (0.59.0); after_tool_call's
 # call:, elapsed_ms: and result: (0.57.0)
 requires_chi: ">= 0.59.0"

data/lib/samagotchi/bundles/slow-commands/plugin.rb

@@ -75,7 +75,11 @@ class Plugin
   TIMED_OUT = /\A#{Regexp.escape(Samagotchi::Tools::Execute::TIMEOUT_PREFIX)} (\d+)s/
   # Still running at the limit, handed over as a task (chi >= 0.59.0).
   HANDED_OVER = /\A#{Regexp.escape(Samagotchi::Tools::Execute::HANDED_OVER)} (\d+)s limit/
-  STOPPED = [Samagotchi::Tools::Execute::STOPPED_BY_USER, Samagotchi::Tools::Execute::NOT_RUN_ON_STOP].freeze
+  # A stopped command's first words: the user's Stop, or a signal to chi
+  # (chi >= 0.62.0; an older chi has no such text).
+  STOPPED = %i[STOPPED_BY_USER NOT_RUN_ON_STOP STOPPED_BY_SIGNAL NOT_RUN_ON_SIGNAL].filter_map do |name|
+    Samagotchi::Tools::Execute.const_get(name) if Samagotchi::Tools::Execute.const_defined?(name)
+  end.freeze
   LEX = Samagotchi::Guardrails::ShellLex
   SHORT_CHARS = 60
   WAIT_DEFAULT = 600

data/lib/samagotchi/bundles/source-links/hooks/source_links.rb

@@ -2,6 +2,7 @@
 
 # Loaded through module_eval: it requires what it uses.
 require "open3"
+require "samagotchi/ref"
 
 # An after_turn hook that links the source refs the model's answer
 # mentions — a JIRA ticket, a GitHub issue, an internal wiki page. In the
@@ -27,6 +28,8 @@ require "open3"
 #           pattern: '\bGH-(\d+)\b'   # full form: a regex
 #           url: 'https://github.com/org/repo/issues/{match}'
 #           case_insensitive: false   # optional, default false
+#           kind: issue               # optional: the refs' kind (below),
+#                                     # default issue
 #         - name: Issues              # `#12` → this project's repo,
 #                                     # `owner/repo#12` → that repo
 #           pattern: '(?<![\w/&])(?:(?<repo>[A-Za-z0-9][\w-]*/[\w.-]*\w))?#(?<num>\d+)\b'
@@ -49,6 +52,12 @@ require "open3"
 # placeholder that can't be filled is not linked; a `{word}` that is none
 # of these stays text (warned at load).
 #
+# Each linked ref is also a ref on the answer (event[:refs], chi 0.61.0):
+# its source's `kind:` (a short lowercase word, default "issue"; not
+# "file"), target {id: the ref's text}, label "<name> <ref>", and one
+# action, "Open in <name>", the ref's URL. A URL that isn't http(s) stays a
+# markdown link only. The web's ref menu shows the action.
+#
 # The note is not stored in the conversation: it is an event, replayed by a
 # UI with the session's cards (a reload keeps it, after the worker stopped
 # too: cards.json). The links are stored as the answer's display. A ref in
@@ -75,6 +84,8 @@ class SourceLinks
   # Placeholders every pattern has: {match} (group 1, else the whole ref),
   # and {repo}/{host} (a named group, else the project's git remote).
   BUILTIN_PLACEHOLDERS = %w[match repo host].freeze
+  # A source's refs' kind, unless its `kind:` says another.
+  DEFAULT_KIND = "issue"
   # `git remote get-url` output: a URL with a scheme, `[user[:pw]@]host[:port]/path`.
   REMOTE_URL = %r{\A(?:https?|ssh|git)://(?:[^/]*@)?(\[[^\]]*\]|[^/:@]+)(?::[^/]*)?(/.*)?\z}i
   # scp-like `[user@]host:path`: a colon before any slash; a leading `/` or
@@ -117,6 +128,7 @@ class SourceLinks
 
     hits = occurrences(text[0, MAX_SCAN])
     linked = present_links(event[:present], text, hits)
+    add_refs(event[:refs], hits)
     return unless @note
 
     found = collect(hits)
@@ -144,6 +156,33 @@ class SourceLinks
     ours.nil? || shown != ours ? nil : linked
   end
 
+  # Each ref the answer links (#link's rule: not in code, the first source
+  # on a ref) as a ref on the answer, once per text and URL. Independent of
+  # the display (chi pairs it with the shown link by its URL). A URL that
+  # isn't http(s) can't be an action: that ref is left out.
+  def add_refs(refs, hits)
+    return unless refs
+
+    seen = {}
+    pos = 0
+    hits.each do |hit|
+      next if hit[:quiet] || hit[:start] < pos
+
+      pos = hit[:finish]
+      key = [hit[:ref], hit[:url]]
+      next if seen.key?(key) || !Samagotchi::RefAction.http_url?(hit[:url])
+
+      seen[key] = true
+      refs.call(match: hit[:ref], kind: hit[:kind], target: { id: hit[:ref] },
+                label: fit("#{hit[:name]} #{hit[:ref]}", Samagotchi::Ref::MAX_LABEL),
+                actions: [{ id: "open", label: fit("Open in #{hit[:name]}", Samagotchi::RefAction::MAX_LABEL), url: hit[:url] }])
+    end
+  end
+
+  # +text+ cut to +max+ characters with a "…", so a long source name can't
+  # get its refs refused.
+  def fit(text, max) = text.length > max ? "#{text[0, max - 1]}…" : text
+
   # The content of the last `role: "model"` message, or nil. Handles both
   # string- and symbol-keyed messages. A turn that ended without a visible
   # answer stores a `kind: turn_note` system message instead, so the role
@@ -188,7 +227,8 @@ class SourceLinks
           next if url.nil?
 
           quiet = inside_any?(code, start, finish) || inside_any?(labels, start, finish)
-          hits << { start: start, finish: finish, name: source[:name], ref: match[0], url: url, quiet: quiet }
+          hits << { start: start, finish: finish, name: source[:name], kind: source[:kind], ref: match[0], url: url,
+                    quiet: quiet }
         end
       rescue Regexp::TimeoutError
         Samagotchi::Log.warn(:hooks, "source_links_timeout",
@@ -407,7 +447,7 @@ class SourceLinks
       name = prefix if name.empty?
       regex = Regexp.new("\\b#{Regexp.escape(prefix)}-(\\d+)\\b", flags, timeout: REGEX_TIMEOUT)
       base = entry["base_url"].to_s
-      { name: name, regex: regex, url: ->(ref, _match) { "#{base}#{ref}" } }
+      { name: name, kind: ref_kind(name, entry["kind"]), regex: regex, url: ->(ref, _match) { "#{base}#{ref}" } }
     elsif !pattern.empty?
       name = "source" if name.empty?
       regex = Regexp.new(pattern, flags, timeout: REGEX_TIMEOUT)
@@ -416,7 +456,7 @@ class SourceLinks
       remote = entry["remote"].to_s.strip
       remote = "origin" if remote.empty?
       hosts = Array(entry["remote_host"]).map { |host| host.to_s.strip.downcase }.reject(&:empty?)
-      source = { name: name, remote: remote, remote_hosts: hosts }
+      source = { name: name, kind: ref_kind(name, entry["kind"]), remote: remote, remote_hosts: hosts }
       source.merge(regex: regex, url: ->(ref, match) { render_url(template, known, match, ref, source) })
     else
       warn_invalid("a source needs a prefix: or a pattern:")
@@ -427,6 +467,21 @@ class SourceLinks
     nil
   end
 
+  # A source's `kind:` for its refs: a short lowercase word other than
+  # "file" (a file ref needs a path), else DEFAULT_KIND, with a warning
+  # when one was given.
+  def ref_kind(name, raw)
+    return DEFAULT_KIND if raw.nil? || raw.to_s.strip.empty?
+
+    kind = raw.to_s.strip
+    return kind if Samagotchi::Ref::KIND.match?(kind) && kind != Samagotchi::Ref::FILE
+
+    Samagotchi::Log.warn(:hooks, "source_links_invalid_kind",
+                         echo: "[samagotchi:hooks] source-links: #{name}: kind #{kind.inspect} is not a short " \
+                               "lowercase word (nor file); using #{DEFAULT_KIND}")
+    DEFAULT_KIND
+  end
+
   # The placeholders of +template+ this pattern can fill: {match}, {repo},
   # {host}, its named groups and {1}…{N} for its N groups. Any other
   # `{word}` stays as text, with one warning here, at compile time.

data/lib/samagotchi/bundles/source-links/manifest.yml

@@ -1,15 +1,15 @@
 ---
 name: source-links
-version: 0.4.0
+version: 0.5.0
 scope: system
 description: Links source refs (JIRA tickets, GitHub issues, …) in the model's answer — inline links in the web, and a one-line note after the turn (note false turns it off); sources are configured patterns
 trust_level: reviewed
-requires_chi: ">= 0.35.0"
+requires_chi: ">= 0.61.0"
 files:
-  source_links.md: sha256:1670a3051b67610f41a680fc8e61bc1c99657a87f0f32121d040e05512896748
+  source_links.md: sha256:ace01a0f7c308a0ae54ece714c31c0e6d7a49c372d98111030e6d268320bed3a
 hooks:
   source_links.rb:
-    sha256: sha256:8ce4d11659f4bc151167f99e47299c0f6ef246797c9167c609c1699e3edea2e5
+    sha256: sha256:8d84c68be88972737905925bc9fc4bd941007fb945e8104e9f6b3d61a1186b89
     event: after_turn
     on_error: log
     priority: 90

data/lib/samagotchi/bundles/source-links/source_links.md

@@ -2,4 +2,4 @@
 
 The `source-links` bundle's `after_turn` hook links the source refs (a JIRA ticket, a GitHub issue, …) in your answers. In the web, each ref in the answer becomes a link; that is how the answer is **shown**, not what you wrote: your own message keeps the plain ref. A `sources: NAME ref → url, …` line right after an answer is the same hook's note (the terminals only see this line). The web leaves it out when markdown is on and the answer links every ref it names; otherwise every UI shows it. The line is **not part of the conversation**: it is an event, so it is not in the session file and you cannot refer back to it. A UI replays it with the session's cards (a page reload keeps it, after the worker stopped too).
 
-The refs come from the `bundles: source-links:` section of config.yml: each source is a `prefix:` + `base_url:` pair (simple) or a `pattern:` regex + `url:` template (full form), plus an optional `max:` for refs per line and `note: false` to drop the line (the web links stay). A `url:` template can take the project's own repo from its git remote, so a bare `#12` links to this project's issue and `owner/repo#12` to that repo's. With no sources configured the hook does nothing. A ref already inside a URL is not linked again, and a ref in code or in a markdown link is not linked in the answer.
+The refs come from the `bundles: source-links:` section of config.yml: each source is a `prefix:` + `base_url:` pair (simple) or a `pattern:` regex + `url:` template (full form), plus an optional `kind:` per source (what the web's ref menu calls its refs, default `issue`), an optional `max:` for refs per line and `note: false` to drop the line (the web links stay). A `url:` template can take the project's own repo from its git remote, so a bare `#12` links to this project's issue and `owner/repo#12` to that repo's. With no sources configured the hook does nothing. A ref already inside a URL is not linked again, and a ref in code or in a markdown link is not linked in the answer.

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.61.0
+version: 0.63.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
   self_map.md: sha256:dfc19266259a9af1e0d769b7e0f67996b740b0c9921fdf3dadad973f6e5c144a
   config_modification_protocol.md: sha256:16403da5dd97a335e19d9d15bb1ba4390237bf9f4869e35d63c172a8828b5ae0
-  memory_guide.md: sha256:d16919387c42d229498f470fc4078245a15faee872480ffbeffe2e27897624e4
+  memory_guide.md: sha256:b0a1ba42c5334d4117b5733c8c26d7477364baca9169b0c0a711de6ac7fc7f3c
   delegated.md: sha256:aedaa1e756a244904c5560fff0424e06fb468bbdcb0358bccefe321d67cd2614

data/lib/samagotchi/bundles/system/memory_guide.md

@@ -94,7 +94,7 @@ Bundles are versioned directories/zips/tar.gz/git URLs with a `manifest.yml` and
 - Integrity: each file's sha256 is recorded at install; a hook/plugin/rule file changed afterwards is not loaded (rules: every call denied) until reinstalled. It is an integrity check, not proof of authorship.
 - Installing = trusting its Ruby code (hooks, plugin), like a gem. Install only copies; the code runs at the next session start (`Engine.new`), so a running worker needs a restart to pick it up.
 - A bundle without `*.md` (btw, mcp, loop-guard) adds no line to the prompt's memory index.
-- Profiles are shipped bundles with only `includes:` (bundle names): `core` (loop-guard, check-in, guardrails, slow-commands; `chi bootstrap` installs it) and `dev` (known-names, mcp, btw, skills, source-links, github-pr, coordinator). `chi bundle install core` installs the ones not installed and records them; a bundle the user uninstalled stays out on a later install, upgrade or `chi update`, which install only bundles new to the profile. `chi bundle uninstall core` removes its recorded bundles, then core (`docs/memory.md` "Bundle profiles").
+- Profiles are shipped bundles with only `includes:` (bundle names): `core` (loop-guard, check-in, guardrails, slow-commands; `chi bootstrap` installs it) and `dev` (known-names, mcp, btw, skills, source-links, github-pr, coordinator, claude-peer). `chi bundle install core` installs the ones not installed and records them; a bundle the user uninstalled stays out on a later install, upgrade or `chi update`, which install only bundles new to the profile. `chi bundle uninstall core` removes its recorded bundles, then core (`docs/memory.md` "Bundle profiles").
 
 ### CLI — `chi bundle`
 

data/lib/samagotchi/context_absorber.rb

@@ -16,8 +16,9 @@ module Samagotchi
   class ContextAbsorber
     # +note+: Engine#add_context_note's hash; +subscription+: the session's
     # Subscription after it (nil: dropped); +wake_note+: the same note with
-    # the wake line, for an update whose source asked to wake (the worker
-    # may start a turn with it), else nil.
+    # the wake line, for an update whose source asked to wake or a session
+    # push source's first text that asked (the worker may start a turn with
+    # it), else nil.
     Delivery = Data.define(:name, :note, :subscription, :wake_note) do
       def initialize(name:, note:, subscription:, wake_note: nil) = super
     end
@@ -93,9 +94,12 @@ module Samagotchi
         "(third-party text, not your user's words):\n> #{quoted}\n#{last_line}"
     end
 
-    def self.attached_text(name:, hint:, why:, summary:)
+    # The attached note's text; a wake turn's (+wake+) ends with the wake
+    # line in place of the background line.
+    def self.attached_text(name:, hint:, why:, summary:, wake: false)
       why_part = why ? " Why: #{why}#{"." unless why.match?(/[.!?]\z/)}" : ""
-      "Attached: #{name}#{" (#{hint})" if hint}.#{why_part}\nSummary: #{summary}\n#{BACKGROUND_LINE} #{read_line(name)}"
+      last_line = wake ? WAKE_LAST_LINE : "#{BACKGROUND_LINE} #{read_line(name)}"
+      "Attached: #{name}#{" (#{hint})" if hint}.#{why_part}\nSummary: #{summary}\n#{last_line}"
     end
 
     def self.read_line(name) = "Read it with context_read(name: \"#{name}\") when your user's request is about it."
@@ -105,6 +109,8 @@ module Samagotchi
     # A source the session sees: attached when it has text and was never
     # noted; updated for a new revision; an error once per run of failures
     # after a success. A source with no text yet waits (nothing to read).
+    # An update that asked to wake carries a wake note, and so does a first
+    # text that asked when #first_text_wakes?.
     def delivery_for(attached, sub, now)
       snapshot = attached.snapshot
       return nil unless snapshot.text?
@@ -112,8 +118,11 @@ module Samagotchi
       name = attached.name
       hint = snapshot.hint || attached.source.hint
       if sub.seen.nil?
-        text = self.class.attached_text(name: name, hint: hint, why: attached.source.why, summary: snapshot.summary)
-        return delivery(name, text_note_id(name, snapshot), text, now, seen(sub, snapshot))
+        args = { name: name, hint: hint, why: attached.source.why, summary: snapshot.summary }
+        found = delivery(name, text_note_id(name, snapshot), self.class.attached_text(**args), now, seen(sub, snapshot))
+        return found unless first_text_wakes?(attached, sub)
+
+        return found.with(wake_note: found.note.merge(text: self.class.attached_text(**args, wake: true)))
       end
       if sub.seen != snapshot.revision
         args = { name: name, hint: hint, summary: snapshot.summary, changes: snapshot.serial - sub.seen_serial }
@@ -131,6 +140,16 @@ module Samagotchi
                sub.with(error_seen: snapshot.error_since))
     end
 
+    # A first text may wake only for a session's pushed source (`chi context
+    # add NAME --push`, attached empty) that asked. Not for a command source
+    # (a URL/provider source has a cmd too): its first fetch runs as it is
+    # attached, while the user is likely looking at the session. Not for a
+    # project source: its first text may predate this session. A blank
+    # Subscription has seen_serial 0, so any revision that asked counts.
+    def first_text_wakes?(attached, sub)
+      attached.source.push? && attached.location.session? && attached.snapshot.wake_serial.to_i > sub.seen_serial
+    end
+
     # A subscription whose source is gone: detached when the session was
     # told of it, dropped quietly otherwise.
     def detached(sub, now)

data/lib/samagotchi/engine.rb

@@ -288,6 +288,9 @@ module Samagotchi
       self.guardrail_state_dir = Session.default_state_dir
       # list_sessions and send_note speak for whichever session runs now.
       @kernel.peers = PeerView.new(self)
+      # A plugin tool's row refs resolve against the session's folder, as
+      # answer refs do (AnswerRefs), not the process's.
+      @kernel.session_cwd = -> { @session&.working_directory }
       @kernel.guardrail_gate = @guardrail_wiring.gate
       # The turn-end warm-up; the kernel asks it for a slot pin per request.
       @prompt_warmup = PromptWarmup.new
@@ -1340,6 +1343,12 @@ module Samagotchi
 
     def session_state_dir = @session_state_dir || Session.default_state_dir
 
+    # The running turn's metrics so far, saved as a turn a worker died in
+    # would leave them (SessionMetrics#persist's running_turn): a worker's
+    # turn checkpoint (TurnCheckpoint) calls it when it writes.
+    # @return [Boolean] whether they were saved
+    def checkpoint_metrics = @metrics.persist(state_dir: session_state_dir, running_turn: true)
+
     # What a Bridge adds to a plugin's ctx.messages while a turn runs (the
     # turn so far, as messages); nil without a Bridge (the REPL).
     attr_writer :running_turn_messages

data/lib/samagotchi/engine_peers.rb

@@ -15,6 +15,7 @@ module Samagotchi
       def project_root = engine.session&.project_root
       def state_dir = engine.peer_state_dir
       def cancelled? = !!engine.active_cancel_controller&.cancelled?
+      def cancel_reason = engine.active_cancel_controller&.reason
       def relay = engine.relay_peer
       def model_ref = engine.effective_model_ref
       def thinking = engine.thinking_override

data/lib/samagotchi/idle_recap.rb

@@ -7,6 +7,7 @@ require "time"
 
 require_relative "idle_client"
 require_relative "idle_target"
+require_relative "image_store"
 require_relative "output_formatter"
 require_relative "steer"
 require_relative "recap_store"
@@ -53,8 +54,6 @@ module Samagotchi
       # separator, while the chat loop writes one message per call.
       TOOL_OUTPUT_SEPARATOR = "\n\n---\n\n"
       TOOL_OUTPUT_HEADER_RE = /\A\[([\w.:-]+)\]/
-      # The text the web sends for a turn of images alone (images.js turnText).
-      IMAGE_ONLY_RE = /\A\s*(?:\[image: [^\]\n]*\]\s*)+\z/
       DELEGATE_REPORT_LINE = "(a delegate session's report, delivered by chi; not the user's words)"
 
       module_function
@@ -76,7 +75,7 @@ module Samagotchi
             # A delegate child's report (ChildReports) is chi's news, not
             # what the user said.
             content = "#{DELEGATE_REPORT_LINE}\n#{content}" if message["source"].to_s == Steer::DELEGATE_REPORT
-            images = IMAGE_ONLY_RE.match?(content) ? [] : image_lines(message["images"])
+            images = ImageRef.placeholder_only?(content) ? [] : image_lines(message["images"])
             [content, *images].reject(&:empty?).join("\n")
           when "model", "assistant"
             strip_thought(message["content"].to_s.gsub(TOOL_CALL_RE, ""))

data/lib/samagotchi/image_store.rb

@@ -159,6 +159,14 @@ module Samagotchi
   # One-line texts about an image ref ({file:, mime:, width:, height:,
   # bytes:, name:, source:}).
   module ImageRef
+    # The text the web sends for a turn of images alone (images.js
+    # turnText): "[image: name]" per image, nothing else.
+    PLACEHOLDER_ONLY_RE = /\A\s*(?:\[image: [^\]\n]*\]\s*)+\z/
+
+    # Whether +text+ is only that placeholder: the images' own lines would
+    # name them a second time.
+    def self.placeholder_only?(text) = PLACEHOLDER_ONLY_RE.match?(text.to_s)
+
     # Claude's rule of thumb (28×28 px per token). About 30% over on the
     # local Qwen, close enough for a label and the context estimate.
     def self.estimated_tokens(ref)