samagotchi 0.148.0 → 0.149.0

data/docs/system-one.md

@@ -3,7 +3,7 @@
 System 1 is the cheap judgment model chi asks small questions: approvals
 ([guardrails.md](guardrails.md#system-1-experimental)), toolkit suggestions
 ([configuration.md](configuration.md#toolkits)), context candidates
-([context.md](context.md)) and bundles' own ([plugins.md](plugins.md#judgments-chijudgment-and-ctxjudge)). Each use keeps its own mode, gates and log. What they share is
+([context.md](context.md)), the objectives' audit ([below](#objectives-in-audit)) and bundles' own ([plugins.md](plugins.md#judgments-chijudgment-and-ctxjudge)). Each use keeps its own mode, gates and log. What they share is
 one host (`system_one.host`, `.model`, `.timeout_ms`) and one layer that saves every ask, so a later comparison or fine-tune has what
 was sent and what came of it. The runs don't leave the machine; a hosted System 1 host sees each state as it is asked.
 
@@ -20,6 +20,7 @@ one warn and never changes the answer. A use that needs the run's id at once pas
 | `approvals.allow` | `GuardrailWiring#system_one_judge` | gates, acted (the judgment line's decision), labels |
 | `toolkit.suggest` | `ToolkitSuggest.judge` | acted (the log's `did`), no labels |
 | `context.candidate` | `ContextJudge.ask` | labels |
+| `objectives.incoming`, `objectives.outgoing` | `ObjectivesAudit` | none: nothing acts on them |
 | `<bundle>.<name>` | `SystemOne::Judgments` (`ctx.judge`, `ctx.judge_later`) | the bundle's: labels, acted |
 
 Not saved: a toolkit warm-up (it goes straight to the backend), `chi guardrails replay`,
@@ -41,6 +42,21 @@ seam is common. A bundle's `judge_later` runs on the Engine's `SideJudgments` un
 at shutdown covers it, and a run cut by that one-second limit is lost. Its asks stay out of the session's spend, as all of System 1's do, and no
 cost cap covers them on a hosted host.
 
+## Objectives in audit
+
+`objectives.system_one: audit` asks whether a message may affect an objective: one yes/no (`affects`) per active objective, each ask
+one request and one run. It is off by default, and asks only with a list that has an active objective, a `system_one.host` and saving on
+(`system_one.runs`). **Mode audit only:** there is no `on`. Nothing reads an answer: no card, no wake, no push, nothing in a prompt, and no turn. A
+per-message judge on an objective didn't work as a gate on the pod (AUC about .5 to .66), so these runs are there to look at, with `chi judgments report objectives.incoming`.
+
+- `objectives.incoming`: a person's message of the owner's of 40 characters or more at its turn's start (`TurnOrigin#human?`: not a reminder's or a delegate's prompt), not a `/` or `!` line, and a note going
+  into the conversation (not the list's own, nor a continue's carry note: `Objectives.outside_note?`). A steer isn't asked about.
+- `objectives.outgoing`: a finished answer of the owner's turn of 400 characters or more, not a cancelled or exhausted one.
+- The state: `objective` (its text and done-when, no id or status) and `message` (2000 characters: a message's head, an answer's tail).
+  **That text goes to the System 1 host**, a hosted one too, and into the run. A participant's turn, a review session and a scratch session are never asked about.
+- At most 6 objectives per message. Each direction has one ask running: what comes meanwhile is a run with `asked: false`, `skipped: busy`.
+- The asks run on `SideJudgments`' threads beside the turn, so a turn doesn't wait; on a one-slot server shared with the session's model, a request can still queue behind or ahead of them. They share `/v1/systemone` with approvals: on a slow one-slot host an approval can wait behind up to 2 in-flight asks and time out to the user. A failed ask is a run with its `failure` and one log line (`system_one_failed`), and a `--no-shared` REPL's stderr shows that line as for any System 1 ask.
+
 ## The store
 
 `<state dir>/system_one/runs/<judgment>/YYYY-MM-DD.jsonl` (`SystemOne::RunsStore`): one file per UTC day,

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

@@ -1,16 +1,16 @@
 ---
 name: coordinator
-version: 0.7.0
+version: 0.8.0
 scope: system
-description: "Coordinate parallel work: the coordinator skill (split the work, one worktree and child session per task, check each report, merges under a guardrail approval (the git-merge rule) or a question, a handoff memory to resume from), /coordinate <goal>, /coordinate resume, /coordinate end, /coordinate review (experimental: a sprint review session to share) and /children; the coordinator toolkit (lean + delegate, delegate_result, list_sessions) and the coding toolkit for build children (child + be concise)"
+description: "Coordinate parallel work: the coordinator skill (split the work, one worktree and child session per task, check each report, merges under a guardrail approval (the git-merge rule) or a question, a handoff memory to resume from), /coordinate <goal>, /coordinate resume, /coordinate end, /coordinate review (experimental: a sprint review session to share) and /children; the coordinator toolkit (lean + delegate, delegate_result, list_sessions, objectives) and the coding toolkit for build children (child + be concise)"
 trust_level: reviewed
 files:
   skill_coordinator.md:
-    sha256: sha256:50b6dc3c2eca885133af9c6518964e6fe862194f2fa4556d9ee5374dde42242a
+    sha256: sha256:1cac885facd28757aaa0197b28889246f845834c17101d59b5625d1b2b89679a
     description: "Coordinate parallel work: split it, delegate each task wait:false in its own worktree (cwd:), check each report, merge under the git-merge approval or ask the user; resume from a handoff_* memory"
 plugin:
   file: plugin.rb
-  sha256: sha256:fa5d7f8b01e465d80012e141abcb2ee27cd5cec43e5a74b9721d435be92d3730
+  sha256: sha256:84535a86b754f3a12cdb2f2591027ea71bbf9ffb74734b1050899b9a4fde07ac
 # the coordinator toolkit needs chi.toolkit and ctx.use_toolkit (0.66.0); the
 # coding toolkit (chi.toolkit prompt:) and the skill's delegate toolkit: need
 # the next chi.
@@ -18,3 +18,5 @@ requires_chi: ">= 0.107.0"
 # /coordinate review uses ctx.sessions.review (the next chi).
 # No requires_chi_next for guardrails/merge.yml: its keys are long supported, and first-ever too-new rules would make a
 # live older worker deny every call. A chi without `chi guardrails rule` gives a usage error, and the skill then asks.
+# Nor for the objectives tool in the kit and the skill: on an older chi the kit's add names nothing (it declares only what
+# is registered), and a call of it comes back as an unknown tool, no harm.

data/lib/samagotchi/bundles/coordinator/plugin.rb

@@ -42,7 +42,8 @@
 # itself (the core child-boundary guardrail), in every mode: nothing to set up.
 #
 # The coordinator toolkit is lean plus the tools that run children
-# (delegate, delegate_result, list_sessions). /coordinate puts the session
+# (delegate, delegate_result, list_sessions) and objectives (the skill's
+# moves). /coordinate puts the session
 # on it before it asks the model (ctx.use_toolkit), which chi allows only
 # before the session's first model reply and outside a turn: otherwise it
 # says to run /toolkit coordinator, unless the session declares delegate
@@ -84,7 +85,7 @@ class Plugin
   def initialize(_settings = {}); end
 
   TOOLKIT = "coordinator"
-  TOOLKIT_TOOLS = %w[delegate delegate_result list_sessions].freeze
+  TOOLKIT_TOOLS = %w[delegate delegate_result list_sessions objectives].freeze
   CODING_TOOLKIT = "coding"
   CODING_PROMPT = "- Be concise in your responses\n- Show file paths clearly when working with files"
 

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

@@ -109,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
@@ -167,3 +174,5 @@ participants: a manager or a teammate brings new context (a priority, a scope ch
   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.148.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

@@ -241,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.
@@ -416,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]"