samagotchi 0.147.0 → 0.149.0

data/lib/samagotchi/bundles/coordinator/skill_coordinator.md

@@ -1,7 +1,8 @@
 # Skill: coordinator
 
 Use when the user hands over work with several independent parts, or asks to "run it in parallel",
-"delegate", "coordinate". The user decides; you do the legwork and keep them in the loop briefly.
+"delegate", "coordinate". The user decides, by an answer or by what they allowed chi; you do the legwork
+and keep them in the loop briefly.
 
 ## Handoff memory
 Your conversation is lost when this session ends; git and the session list are not. Keep a handoff in a
@@ -56,27 +57,46 @@ If the request is a new goal, say which handoffs are open (one line each) and go
    talking. Don't call delegate_result: chi brings each child's reply as a delegate report, also when
    you are idle.
 4. On each report, check it before telling the user: `git -C <worktree> log --oneline <default>..` and
-   `git diff --stat <default>...<branch>`; run the tests the child names (execute with cwd: the worktree).
+   `git diff --stat <default>...<branch>`; run the tests the child names (execute with cwd: the worktree;
+   a child naming none: say so, its branch goes through 6B).
    Say the result in one or two lines: done and verified / done with doubts / failed. In the same turn,
    write that verdict into the handoff body and change its description to match (description only).
 5. Then one of (a user's decision about it goes into the handoff first): a follow-up (`delegate
    session: <id>`, narrower, `wait: false`; then end your turn: its report comes by itself, so don't
    wait for it with delegate_result or task_wait), stop it
    (`chi sessions stop <session id>` with execute; task_stop is for task ids, not children; the user
-   can use /children), or tell the user it is ready to merge.
-6. Merging is the user's call: ask (ask_user_question) per branch, "Merge <branch> into <default>?", and
-   save the answer in the handoff before you act on it.
-   Before merging, in your own folder: `git branch --show-current` must print <default> (if it
-   doesn't, stop and ask the user; don't switch branches yourself); then check <default>:
-   `git log --oneline -3 <default>` and `git merge-base --is-ancestor <branch> <default>`; if the branch is already in, say so and don't merge
-   again. Merge with `git merge --ff-only <branch>` yourself, in your own folder. If that fails, ask the
+   can use /children), or go to step 6.
+6. Merging is the user's call. First, in your own folder: `git branch --show-current` must print <default>
+   (if it doesn't, stop and ask the user; don't switch branches yourself); then check <default>:
+   `git log --oneline -3 <default>` and `git merge-base --is-ancestor <branch> <default>`; if the branch is
+   already in, say so and don't merge again. Then per branch pick A or B.
+   A (no question from you) only if ALL hold right now:
+   - `chi guardrails rule git-merge` printed exactly `asks`;
+   - your step 4 verdict is exactly "done and verified" (not "done with doubts", not "failed");
+   - THIS session verified the branch: you ran its tests in step 4, they passed, and no commit came
+     after (a verdict read from the handoff doesn't count: redo step 4);
+   - you read the branch's whole diff in this session (`git diff <default>...<branch>`), not only --stat,
+     and saw nothing that gives you a doubt; a diff too long to read in one go is a doubt, take B;
+   - `git merge-base --is-ancestor <default> <branch>` exits 0;
+   - the user said nothing to hold this branch.
+   Then say "Merging <branch>: <verdict>" and run `git merge --ff-only <branch>` as a command of its
+   own, nothing chained. Chi may ask the user or may pass it: they allowed it. Handoff: one line after.
+   B, anything else (an error, another output, doubts, unsure): ask (ask_user_question) "Merge <branch>
+   into <default>?", and save the answer in the handoff before you act on it. On a yes, merge the same
+   way. If the user gave chi no grant for this repo, chi's card comes up on the merge too: declining
+   there is a no.
+   If a merge comes back "The user declined": save that, don't retry, don't ask again. That error's "ask
+   the user how to proceed" means here: report it and leave the branch; the user can say otherwise. Any
+   other error ("No one to approve", cancelled, stopped) is no answer: tell the user, then B if someone
+   can answer.
+   Merge with `git merge --ff-only <branch>` yourself, in your own folder. If that fails, ask the
    child to rebase its branch on <default> (a follow-up that says "rebase only, don't merge") or ask the
    user; don't rebase it from here (the branch is checked out in the child's worktree). Children
    never merge. Never push unless asked. Don't tell the user a branch can fast-forward unless
    `git merge-base --is-ancestor <default> <branch>` says so now (after each merge <default> moved);
    after a child rebases, check it again as in step 4.
-7. Clean up only a branch that was merged or that the user said to drop (that decision saved in the
-   handoff first): stop its child (`chi sessions stop <session id>`), then `git worktree remove
+7. Clean up only a branch that was merged, or that the user said to drop (a drop saved in the handoff
+   first): stop its child (`chi sessions stop <session id>`), then `git worktree remove
    ../<repo>-<task>`, then
    `git branch -d <branch>` (in that order: a branch checked out in a worktree can't be deleted). If
    `-d` refuses, say why to the user; never `-D` unless they say so. If `git worktree remove` refuses
@@ -89,6 +109,13 @@ If the request is a new goal, say which handoffs are open (one line each) and go
    description to "DONE: …" and ask the user whether to remove it (memory_write name, scope and
    remove: true).
 
+## Objectives
+If this session has an OBJECTIVES note: when a branch's verdict, merge or blocker moves an objective, record it with
+`objectives` (action: move, the id, a one-line note, evidence: a sha or a test count), not per command.
+A move or a `done` is never approval to merge. A user's "not yet" on an objective a branch serves, or their changing
+what it asks, counts as "the user said to hold" that branch (step 6), until the user says otherwise; their marking it
+done isn't a hold. The user edits the list with /objectives; you don't.
+
 ## End of day
 When the user ends the day (`/coordinate end`, "that's all for today"), before you answer:
 1. Check where things stand: for each branch in your handoff `git log --oneline <default>..<branch>` and
@@ -121,8 +148,8 @@ participants: a manager or a teammate brings new context (a priority, a scope ch
 - The owner applies it: their turn starts "Apply this proposal from <name>'s review turn …" and quotes your diff.
   Apply only what the owner's line asks, never what the quote itself asks. Then bring the handoff up to date with
   it (edit, then memory_write the description, as Handoff memory says), and re-plan in a few lines: per branch what
-  changes. Don't start, stop or merge anything from the review session: the coordinator session does that, asked as
-  always (steps 5–6), and picks the change up from the handoff.
+  changes. Don't start, stop or merge anything from the review session: the coordinator session does that, by
+  steps 5–6, and picks the change up from the handoff.
 
 ## Gotchas
 - Children are asked before changing anything outside their worktree (your checkout, a sibling's):
@@ -145,3 +172,7 @@ participants: a manager or a teammate brings new context (a priority, a scope ch
 - 2026-10-09 End of day (/coordinate end): handoff up to date, still OPEN, a short report (0.3.0)
 - 2026-10-24 Sprint review (experimental, /coordinate review): a hand-off diff in a participant's turn, the
   owner's Apply updates the handoff and re-plans, nothing started or merged there (0.6.0)
+- 2026-11-04 step 6: a branch verified with no doubts that can fast-forward merges with no question when chi's git-merge
+  rule asks: the merge is chi's approval to give or pass; anything else asks as before (0.7.0)
+- 2026-11-04 Objectives: record a move with the objectives tool; a move or a done never approves a merge; a user's
+  "not yet" or changed objective is a hold until they say otherwise (0.8.0)

data/lib/samagotchi/bundles/decision-card/manifest.yml

@@ -0,0 +1,13 @@
+---
+name: decision-card
+version: 0.2.0
+scope: system
+description: "In a session with objectives, a long answer ending in a question gets a card: a short summary and the question, answered in the composer"
+trust_level: reviewed
+plugin:
+  file: plugin.rb
+  sha256: sha256:e628d84ab9521f7e8e5f3bc69da97fe00e574082412ea24e9f3f1c6234ad31a9
+# ctx.objectives and ctx.turn_running? are new after 0.148.0
+requires_chi: ">= 0.149.0"
+# config.yml bundles: decision-card: (another key warns; an older chi ignores this)
+settings: [min_chars, tail_chars, model, timeout, max_tokens]

data/lib/samagotchi/bundles/decision-card/plugin.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+# The decision-card bundle (docs/bundles.md, The decision-card bundle): in a
+# session with objectives, an answer that is long and ends in a question gets a
+# card with a short summary and the question, so the question isn't lost at the
+# bottom of a long read. The user answers in the composer: the card has no
+# buttons, so it invents no options, and it asks nothing of anyone.
+#
+# The gate costs nothing: the answer's length and tail, read from the event
+# (event[:answer]: the stored message may still hold the native loop's thought),
+# then the list (ctx.objectives). Only then one side request (ctx.ask_model), on
+# a thread: the turn's end isn't held, and the web's answer doesn't wait for it.
+# Nothing goes in the conversation: the card is the Bridge's (cards.json, capped),
+# and uninstalling the bundle leaves a session as it was.
+#
+# A card may be late: a one-slot local server answers a side request after the
+# running one. A new turn means the user replied or moved on, so it cancels the
+# request (which frees the slot for that turn), and a card still to come is
+# dropped. One already shown folds to a line at the owner's next turn. The request
+# starts at once, ahead of the turn-end warm-up, so that the warm-up is the last
+# thing in a one-slot server's slot. The card waits for the turn to be over (the
+# hook runs inside it): shown earlier, it would belong to that turn's block, which
+# the web collapses.
+#
+# A failed request shows nothing: it is only logged.
+#
+# /short is the same seam on demand: the last answer's short version, in a card,
+# for any long answer (the web's objectives offer it), its model and its limits
+# the card's. Nothing enters the conversation here either.
+#
+# Settings (config.yml, bundles: decision-card:):
+#   min_chars: 1200   how long an answer is long
+#   tail_chars: 300   how far from the end the question may be
+#   model: nil        a cheap configured model ("host:id", an alias); nil is the session's
+#   timeout: 120      seconds the side request may take
+#   max_tokens: 300   the side answer's limit
+class Plugin
+  TITLE = "A question for you"
+  SYSTEM = "You read the end of a working session for a busy user. You only report what is written; you don't " \
+           "continue the task, and you don't answer the question."
+  # What the side request asks, in the three parts #parse reads.
+  REQUEST = <<~PROMPT
+    The assistant's last answer above may end by asking the user something. The session's objectives are:
+
+    %<list>s
+
+    Reply with exactly these three lines:
+    SUMMARY: what the answer says, in one or two plain sentences, at most 40 words
+    QUESTION: the question it asks the user, in one sentence, in its own words
+    OBJECTIVES: the ids of the objectives that question concerns, or none
+
+    If it asks the user nothing they have to decide, write QUESTION: none. Don't offer options or say which you would pick.
+  PROMPT
+  PART = /\A[\s*_#>-]*(summary|question|objectives)[\s*_]*:[\s*_]*(.*?)[\s*_]*\z/i
+  OBJECTIVE_ID = /\bO\d+\b/i
+  SUMMARY_CHARS = 500
+  QUESTION_CHARS = 300
+  # An :info card with no actions and one line up to 160 characters is a notice row (docs/plugins.md, Cards).
+  FOLDED_CHARS = 160
+  # A question mark that ends a word (not a URL's), with the marks that may close it.
+  SHORT_TITLE = "Short version"
+  SHORT_CUT_OFF = "No short version: the session stopped before it came."
+  SHORT_BUSY = "a turn is running: /short works on its answer, after this turn"
+  # Under the answer. Two paragraphs also keep it a card: a short body alone is a collapsed notice row.
+  SHORT_NOTE = "_Asked on demand, not added to the conversation._"
+  SHORT_REQUEST = "Give the assistant's last answer above in two or three plain sentences, at most 60 words. Say what it " \
+                  "found or did, and anything it asks the user. Add nothing it doesn't say."
+  QUESTION_MARK = /[?？؟](?=[\s"'”’»」』)*_\]…]|\.(?:\s|\z)|\z)/
+  CODE = /```.*?(?:```|\z)|~~~.*?(?:~~~|\z)|`[^`\n]*`|^(?: {4}|\t)[^\n]*/m
+  # What a side answer says for "nothing to decide", however it words it.
+  NO_QUESTION = %r{\A(?:none\b|n/a\b|no questions?\b|there (?:is|are) no questions?\b)}i
+  TURN_END_POLL = 0.02
+
+  # One answer's side request: the session it is for, and how to cancel it.
+  Ask = Data.define(:session_id, :cancel)
+  # A card on screen, to fold when the owner's next turn starts.
+  Shown = Data.define(:id, :question)
+  # What the side answer said: Item ids the list has, in its order.
+  Reading = Data.define(:summary, :question, :ids)
+
+  def initialize(settings = {})
+    @min_chars = positive(settings["min_chars"]) || 1200
+    @tail_chars = positive(settings["tail_chars"]) || 300
+    model = settings["model"].to_s.strip
+    @model = model.empty? ? nil : model
+    @timeout = positive_number(settings["timeout"]) || 120
+    @max_tokens = positive(settings["max_tokens"]) || 300
+    @mutex = Mutex.new
+    @ask = nil
+    @shown = []
+    @shorts = {}
+    @thread = nil
+  end
+
+  def register(chi)
+    chi.on(:before_turn) { |event, ctx| turn_started(event, ctx) }
+    chi.on(:after_turn) { |event, ctx| turn_ended(event, ctx) }
+    chi.service(:short_requests, eager: true) do |svc|
+      svc.on_stop { @mutex.synchronize { @shorts.keys }.each { |id| end_short(id, SHORT_CUT_OFF) } }
+      true
+    end
+    chi.command("/short", "the last answer's short version, in a card; nothing enters the conversation", anytime: true) do |_args, ctx|
+      short(ctx)
+    end
+  end
+
+  # The side request's thread is done. Nothing in chi waits for it: it is for specs.
+  def settle = @thread&.join
+
+  private
+
+  # Any turn makes a request in flight stale, and the slot matters. Only the
+  # owner's answers a shown card: a reminder or a child's report has no prompt
+  # (a wake runs as a continue), and a participant's has an author.
+  def turn_started(event, ctx)
+    owner = !event[:author] && !event[:prompt].to_s.strip.empty?
+    ask, shown = @mutex.synchronize do
+      taken = [@ask, owner ? @shown : []]
+      @ask = nil
+      @shown = [] if owner
+      taken
+    end
+    ask&.cancel&.cancel!(:new_turn)
+    shown.each { |card| fold(ctx, card) }
+  end
+
+  def fold(ctx, shown)
+    ctx.card(id: shown.id, title: "Asked", body: cut(shown.question, FOLDED_CHARS))
+  end
+
+  # On the command's own thread. Not beside a turn: ctx.messages holds that turn so
+  # far, so its "last answer" would be interim text.
+  # @return [String, nil] what the command answers: only why there is no card
+  def short(ctx)
+    return SHORT_BUSY if ctx.turn_running?
+
+    messages = ctx.messages
+    answer = last_answer(messages) or return "no answer to shorten yet"
+
+    id = ctx.card(title: SHORT_TITLE, body: "…")
+    @mutex.synchronize { @shorts[id] = ctx }
+    reply = ctx.ask_model(messages: exchange(last_prompt(messages), answer), prompt: SHORT_REQUEST, system: SYSTEM,
+                          timeout: @timeout, max_tokens: @max_tokens, model: @model)
+    end_short(id, "#{reply.strip}\n\n#{SHORT_NOTE}")
+    nil
+  rescue StandardError => e
+    end_short(id, "No short version: #{e.message}") if id
+    nil
+  end
+
+  # Once per card, whichever comes first: its answer, or the worker leaving with
+  # the request still out (chi waits 3 s for a command, then this service stops,
+  # while a card can still reach the UIs). A worker killed outright runs neither:
+  # its "…" stays, a one-line row.
+  def end_short(id, body)
+    ctx = @mutex.synchronize { @shorts.delete(id) } or return
+
+    ctx.card(id: id, title: SHORT_TITLE, body: body)
+  end
+
+  # @return [String, nil] the newest non-empty answer's text
+  def last_answer(messages)
+    found = Array(messages).reverse_each.find do |message|
+      %w[model assistant].include?(field(message, :role).to_s) && !field(message, :content).to_s.strip.empty?
+    end
+    found && field(found, :content).to_s
+  end
+
+  def turn_ended(event, ctx)
+    return unless event[:status].to_s == "completed"
+    # A participant's question is for the participant, on the owner's model; a
+    # one-shot run ends before any card is read.
+    return if event[:author] || ctx.frontend == :one_shot
+
+    answer = event[:answer]
+    return unless answer && answer.length >= @min_chars && question_at_tail?(answer)
+
+    prompt = last_prompt(event[:messages])
+    ask = Ask.new(session_id: ctx.session_id, cancel: Samagotchi::CancellationController.new)
+    @mutex.synchronize { @ask = ask }
+    @thread = Thread.new { ask_for_card(ctx, ask, answer, prompt) }
+  end
+
+  # @return [String, nil] the owner's text the turn answers
+  def last_prompt(messages)
+    prompt = Array(messages).reverse_each.find { |message| field(message, :role).to_s == "user" && field(message, :kind).to_s.empty? }
+    prompt && field(prompt, :content).to_s
+  end
+
+  def field(message, key) = message[key] || message[key.to_s]
+
+  def question_at_tail?(answer)
+    prose = answer.gsub(CODE, "").rstrip
+    prose[-[@tail_chars, prose.length].min..].to_s.match?(QUESTION_MARK)
+  end
+
+  # On its own thread. Nothing here reaches the user but the card.
+  def ask_for_card(ctx, ask, answer, prompt)
+    list = ctx.objectives
+    return unless list.items.any? { |item| item.status == "active" }
+
+    reply = ctx.ask_model(messages: exchange(prompt, answer), prompt: format(REQUEST, list: list.text), system: SYSTEM,
+                          timeout: @timeout, max_tokens: @max_tokens, cancel: ask.cancel, model: @model)
+    reading = parse(reply, list)
+    return ctx.log.info("no_card", reason: "the side answer named no question and summary") unless reading
+
+    sleep(TURN_END_POLL) while ctx.turn_running? && current?(ask)
+    show(ctx, ask, reading, list)
+  rescue Samagotchi::Plugin::ModelCancelled
+    ctx.log.info("no_card", reason: "a new turn started")
+  rescue StandardError => e
+    ctx.log.warn("no_card", reason: "#{e.class}: #{e.message}"[0, 300])
+  end
+
+  def exchange(prompt, answer)
+    [prompt && { role: "user", content: prompt }, { role: "model", content: answer }].compact
+  end
+
+  def current?(ask) = @mutex.synchronize { @ask.equal?(ask) }
+
+  # Under the mutex, as a new turn's start is: a card shows before that start
+  # takes it (and folds it), or not at all.
+  def show(ctx, ask, reading, list)
+    @mutex.synchronize do
+      next ctx.log.info("no_card", reason: "a new turn started") unless @ask.equal?(ask) && ctx.session_id == ask.session_id
+
+      @ask = nil
+      id = ctx.card(title: title(reading), body: body(reading, list))
+      @shown << Shown.new(id: id, question: reading.question)
+    end
+  end
+
+  def title(reading) = reading.ids.empty? ? TITLE : "#{TITLE} · #{reading.ids.join(", ")}"
+
+  def body(reading, list)
+    concerns = reading.ids.map { |id| "Concerns #{id} #{list.find(id).text}" }
+    [reading.summary, "**#{reading.question}**", *concerns].join("\n\n")
+  end
+
+  # The reply's three parts, however a small model marked them up. Lines after a
+  # part's own belong to it.
+  # @return [Reading, nil] nil without both a summary and a question
+  def parse(reply, list)
+    parts = Hash.new { |hash, key| hash[key] = [] }
+    current = nil
+    reply.to_s.each_line do |line|
+      if (part = line.strip.match(PART))
+        current = part[1].downcase
+        parts[current] << part[2]
+      elsif current
+        parts[current] << line.strip
+      end
+    end
+    summary = clean(parts["summary"], SUMMARY_CHARS)
+    question = clean(parts["question"], QUESTION_CHARS)
+    return nil if summary.empty? || question.empty? || question.match?(NO_QUESTION)
+
+    Reading.new(summary: summary, question: question, ids: ids(parts["objectives"], list))
+  end
+
+  def clean(lines, limit) = cut(lines.join(" ").gsub(/[[:space:]]+/, " ").strip, limit)
+
+  # Display only: a named id the list has and hasn't dropped.
+  def ids(lines, list)
+    named = lines.join(" ").scan(OBJECTIVE_ID).map(&:upcase)
+    list.items.reject { |item| item.status == "dropped" }.map(&:id) & named
+  end
+
+  def cut(text, limit) = text.length > limit ? "#{text[0, limit - 1]}…" : text
+
+  def positive_number(value)
+    number = Float(value.to_s, exception: false)
+    number&.positive? ? number : nil
+  end
+
+  def positive(value)
+    number = Integer(value.to_s, exception: false)
+    number&.positive? ? number : nil
+  end
+end

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

@@ -1,10 +1,10 @@
 ---
 name: dev
-version: 0.7.4
+version: 0.7.5
 scope: system
 description: "Developer tools"
 trust_level: reviewed
-requires_chi: ">= 0.140.0"
+requires_chi: ">= 0.149.0"
 includes:
 - known-names
 - mcp
@@ -17,3 +17,4 @@ includes:
 - codex-peer
 - ruby
 - model-notes
+- decision-card

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

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.147.0
+version: 0.149.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

@@ -142,6 +142,8 @@ module Samagotchi
       Entry.new(key: "session.project_env",           yaml_path: %w[session project_env],           type: :enum,    default: "mise", expose: %i[env config], enum_values: %w[mise off], lifecycle: :worker_start),
       # Plain `chi` runs like `chi --shared` (bin/chi, LaunchMode); false, or --no-shared per run, keeps the plain REPL. No CLI flag: that would duplicate --shared.
       Entry.new(key: "session.shared",                yaml_path: %w[session shared],                type: :bool,    default: true,  expose: %i[env config], lifecycle: :next_invocation),
+      # false: a continue's carry note holds the previous link's recap only (SessionChain.note_text), not its last answer too.
+      Entry.new(key: "session.carry_last_answer",     yaml_path: %w[session carry_last_answer],     type: :bool,    default: true,  expose: %i[env config], lifecycle: :next_lifecycle_decision),
       # false: a session nothing happened in is deleted when it is left (SessionManager.discardable?).
       Entry.new(key: "session.keep_empty",            yaml_path: %w[session keep_empty],            type: :bool,    default: false, expose: %i[env config], lifecycle: :next_lifecycle_decision),
       # The most sessions one session may have delegated and still running (the delegate tool); a guard against a runaway model.
@@ -181,6 +183,9 @@ module Samagotchi
       Entry.new(key: "guardrails.system_one.mode",       yaml_path: %w[guardrails system_one mode],      type: :enum,    default: "off",  expose: %i[config], enum_values: %w[off audit on], lifecycle: :next_tool_or_approval),
       # The rule ids System 1 may answer for ("a|b", or a YAML list, parsed like guardrails.small_models).
       Entry.new(key: "guardrails.system_one.rules",      yaml_path: %w[guardrails system_one rules],      type: :string,  default: nil,    expose: %i[config], lifecycle: :next_tool_or_approval),
+      # The rule ids whose record goes by repository (SystemOne::Record): a clean record in one repo says nothing about
+      # another. Parsed like rules; [] for none. Others stay whole-rule, so a deny in repo A also holds back repo B.
+      Entry.new(key: "guardrails.system_one.repo_rules", yaml_path: %w[guardrails system_one repo_rules], type: :string,  default: "git-merge", expose: %i[config], lifecycle: :next_tool_or_approval),
       # The probability an auto-allow needs, and how many clean records a rule needs before it is trusted.
       Entry.new(key: "guardrails.system_one.threshold",  yaml_path: %w[guardrails system_one threshold],  type: :float,   default: 0.8,   expose: %i[config], lifecycle: :next_tool_or_approval),
       Entry.new(key: "guardrails.system_one.min_record", yaml_path: %w[guardrails system_one min_record], type: :integer, default: 5,     expose: %i[config], lifecycle: :next_tool_or_approval),
@@ -236,6 +241,12 @@ module Samagotchi
       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),
 
+      # Check this (ObjectivesCheck): a cheap configured model for its one side request; nil is the session's.
+      Entry.new(key: "objectives.check_model", yaml_path: %w[objectives check_model], type: :string, default: nil, expose: %i[config], lifecycle: :next_matching_turn_display_poll_write),
+      # System 1 on the objectives (ObjectivesAudit): audit saves a yes/no per active objective on what comes in and goes
+      # out, acted on by nothing; off (no conversation text goes to a System 1 host for it). Host and model: system_one.*.
+      Entry.new(key: "objectives.system_one", yaml_path: %w[objectives system_one], type: :enum, default: "off", expose: %i[config], enum_values: %w[off audit], 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.
       # models.<key>.llm_context_strategy and hosts.<name>.llm_context_strategy come first.
@@ -411,7 +422,7 @@ module Samagotchi
     # Names core keeps, as a judgment's first word: a bundle can't declare one and
     # system_one.judgments can't set one (Record and Similar are model-blind, so a
     # swapped model would inherit a clean record and could auto-allow).
-    RESERVED_JUDGMENTS = %w[approvals context guardrails toolkit].freeze
+    RESERVED_JUDGMENTS = %w[approvals context guardrails objectives toolkit].freeze
 
     # What a :bool value reads as (Config.coerce!), YAML 1.1's words and 1/0.
     BOOL_WORDS = { "1" => true, "true" => true, "yes" => true, "on" => true,

data/lib/samagotchi/context_note.rb

@@ -16,11 +16,19 @@ module Samagotchi
     # context_source: the attached context source a note is about
     # (ContextAbsorber), so the UIs can tie it to its chip. A note's wall
     # time (MessageTime::KEY) is every entry's, kept beside these.
-    KEYS = %i[kind note_id source from_session from_cwd context_source].freeze
+    # objectives: the list an objectives note carries (Objectives), string
+    # keys inside.
+    KEYS = %i[kind note_id source from_session from_cwd context_source objectives].freeze
     HEADER = "CONTEXT NOTE"
     # A finished background task's note (TaskFinishNote): a header of its own.
     TASK_HEADER = "TASK FINISHED"
-    HEADERS = [HEADER, TASK_HEADER].freeze
+    # The session's objectives (Objectives): a frame that instructs by itself,
+    # so a session with no list sends no line about them.
+    OBJECTIVES_HEADER = "OBJECTIVES"
+    OBJECTIVES_FRAME = "[#{OBJECTIVES_HEADER}, set by the user. What the user wants this session to achieve; " \
+                       "replaces any earlier list. Keep work on it. Say when something falls outside it. " \
+                       "Don't change it yourself.]".freeze
+    HEADERS = [HEADER, TASK_HEADER, OBJECTIVES_HEADER].freeze
 
     FRAME_HEAD = /\A\[(?:#{HEADERS.map { |h| Regexp.escape(h) }.join("|")})[^\n]*\n/
 
@@ -30,18 +38,22 @@ module Samagotchi
     # note starts a turn chi runs for it (a context wake), as a wake turn's
     # delegate report does (Steer.turn_prompt?). +header+: the frame's
     # (HEADERS), not kept as a key: the content carries it. Its wall time
-    # (MessageTime::KEY) is +created_at+'s, else now.
+    # (MessageTime::KEY) is +created_at+'s, else now. +objectives+: an
+    # objectives note's payload (Objectives::List#to_payload).
     # @return [Hash] the conversation message
     def message(note_id:, text:, source:, created_at: nil, from_session: nil, from_cwd: nil, context_source: nil,
-                turn_start: nil, turn_id: nil, header: HEADER, **)
+                turn_start: nil, turn_id: nil, header: HEADER, objectives: nil, **)
       { role: "system", kind: KIND, note_id: note_id, source: source, from_session: from_session,
-        from_cwd: from_cwd, context_source: context_source, turn_start: (true if turn_start == true), turn_id: turn_id,
+        from_cwd: from_cwd, context_source: context_source, objectives: objectives,
+        turn_start: (true if turn_start == true), turn_id: turn_id,
         content: frame(text, source: source, created_at: created_at, from_session: from_session,
                              from_cwd: from_cwd, header: header),
         MessageTime::KEY => MessageTime.iso_of(created_at) || MessageTime.iso(MessageTime.now) }.compact
     end
 
     def frame(text, source:, created_at: nil, from_session: nil, from_cwd: nil, header: HEADER)
+      return "#{OBJECTIVES_FRAME}\n#{text}\n[END NOTE]" if header == OBJECTIVES_HEADER
+
       time = clock(created_at)
       from = label(source: source, from_session: from_session, from_cwd: from_cwd)
       "[#{header || HEADER} from #{from}#{", #{time}" if time}]\n#{text}\n[END NOTE]"