samagotchi 0.2.0 → 0.3.0

data/lib/samagotchi/config.rb

@@ -116,7 +116,6 @@ module Samagotchi
       Entry.new(key: "context.status_cadence",   yaml_path: %w[context status_cadence],   type: :integer, default: 0,               expose: %i[env config cli]),
 
       Entry.new(key: "thinking.ui",              yaml_path: %w[thinking ui],              type: :string, default: nil,              expose: %i[env config cli]),
-      Entry.new(key: "thinking.preview_lines",   yaml_path: %w[thinking preview_lines],   type: :integer, default: 1,               expose: %i[env config cli]),
       Entry.new(key: "thinking.render_interval", yaml_path: %w[thinking render_interval], type: :float,   default: 0.08,            expose: %i[env config cli]),
       Entry.new(key: "thinking.turn_preamble",   yaml_path: %w[thinking turn_preamble],   type: :bool,   default: true,             expose: %i[env config cli]),
 
@@ -126,6 +125,9 @@ module Samagotchi
       Entry.new(key: "retry.max",                yaml_path: %w[retry max],                type: :integer, default: 5,               expose: %i[env config cli]),
       Entry.new(key: "retry.base_delay",         yaml_path: %w[retry base_delay],         type: :float,   default: 0.5,             expose: %i[env config cli]),
       Entry.new(key: "retry.max_delay",          yaml_path: %w[retry max_delay],          type: :float,   default: 8.0,             expose: %i[env config cli]),
+      # Asks again in the same turn after an empty answer (EmptyAnswerRetry);
+      # 0 = off, capped at 3. No CLI flag: workers get no CLI args.
+      Entry.new(key: "retry.empty_answer",       yaml_path: %w[retry empty_answer],       type: :integer, default: 1,               expose: %i[env config]),
 
       Entry.new(key: "read.truncate_at_bytes",        yaml_path: %w[read truncate_at_bytes],        type: :integer, default: 65_536,   expose: %i[env config cli]),
       Entry.new(key: "read.preview_bytes",            yaml_path: %w[read preview_bytes],            type: :integer, default: 12_288,   expose: %i[env config cli]),
@@ -141,6 +143,8 @@ module Samagotchi
       Entry.new(key: "web.markdown",             yaml_path: %w[web markdown],             type: :bool,    default: false,           expose: %i[env config cli]),
       # The page shows each turn as one block of generations (the live one at the bottom); false brings back the row of bubbles; ?view=turn|chat overrides it per page load.
       Entry.new(key: "web.turn_view",            yaml_path: %w[web turn_view],            type: :bool,    default: true,           expose: %i[env config cli]),
+      # Quick replies next to Annotate in the page's selection bubble, "|"-separated (a YAML list works too); "" leaves only Annotate.
+      Entry.new(key: "web.annotate_presets",     yaml_path: %w[web annotate_presets],     type: :string, default: "Agreed|Could you please elaborate?", expose: %i[env config cli]),
 
       Entry.new(key: "no_interrupt",             yaml_path: %w[no_interrupt],             type: :bool,   default: false,            expose: %i[env config cli]),
       Entry.new(key: "no_default_input",         yaml_path: %w[no_default_input],         type: :bool,   default: false,            expose: %i[env config cli]),
@@ -149,9 +153,23 @@ module Samagotchi
       Entry.new(key: "default.input",            yaml_path: %w[default input],            type: :string, default: nil,              expose: %i[env config]),
       Entry.new(key: "history.file",             yaml_path: %w[history file],             type: :string, default: nil,              expose: %i[env config]),
       Entry.new(key: "skip_agent_md",            yaml_path: %w[skip_agent_md],            type: :bool,   default: false,            expose: %i[env config]),
-      Entry.new(key: "bridge.enable",            yaml_path: %w[bridge enable],            type: :bool,   default: false,            expose: %i[env config]),
     ].freeze
 
+    # Top-level maps read by their own code, whose entry names and contents
+    # are the user's: ConfigFile.model_aliases / preloaded_memories,
+    # Hooks::Loader, Engine#read_bundle_settings.
+    FREE_FORM_MAPS = %w[model_aliases hooks bundles memories].freeze
+    # Maps of named entries and the keys an entry may hold
+    # (ConfigFile.hosts_config, ConfigFile.model_settings).
+    MAP_ENTRY_KEYS = {
+      "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling enabled].freeze,
+      "models" => %w[profile vision sampling].freeze
+    }.freeze
+    # Section keys beyond the registry's: guardrails' YAML rules (Engine#guardrail_rules).
+    SECTION_EXTRA_KEYS = { "guardrails" => %w[rules disable].freeze }.freeze
+    # Removed settings that warn on their own (Engine.warn_removed_backend_setting).
+    REMOVED_KEYS = %w[backend].freeze
+
     # Fast lookup maps
     BY_KEY = ENTRIES.each_with_object({}) { |e, h| h[e.key] = e }.freeze
     BY_ENV = ENTRIES.each_with_object({}) do |e, h|
@@ -186,7 +204,8 @@ module Samagotchi
         return nil if raw.nil?
         # For string, preserve as-is (including trailing spaces like "Please ")
         if entry.type == :string
-          str = raw.to_s
+          # A YAML list for a "|"-separated setting (web.annotate_presets).
+          str = raw.is_a?(Array) ? raw.join("|") : raw.to_s
           return nil if str.empty? && entry.type != :string
           return str
         end
@@ -286,21 +305,31 @@ module Samagotchi
         end
       end
 
-      # Lookup yaml_path in nested hash, accepting snake leaf, kebab alias,
-      # entry-specific yaml_aliases, and legacy flat UPPER keys (e.g.,
-      # SAMAGOTCHI_DEFAULT_MODEL) for transition.
+      # Lookup yaml_path in nested hash, accepting snake leaf, kebab alias and
+      # entry-specific yaml_aliases, then legacy flat UPPER keys (e.g.,
+      # SAMAGOTCHI_DEFAULT_MODEL) for transition: the nested key wins when a
+      # file has both (ConfigFile.load_global_env! warns about that).
       def lookup_yaml(data, yaml_path)
         entry = ENTRIES.find { |e| e.yaml_path == yaml_path }
-        # Legacy flat top-level fallback (transition): e.g., file contains SAMAGOTCHI_DEFAULT_MODEL
-        if entry && data.is_a?(Hash)
-          if data.key?(entry.env_key)
-            return data[entry.env_key]
-          end
-          Array(entry.aliases).each do |a|
-            return data[a] if data.key?(a)
-            return data[a.to_sym] if data.key?(a.to_sym)
-          end
+        nested = lookup_nested(data, yaml_path, entry)
+        return nested unless nested.nil?
+
+        lookup_legacy(data, entry)
+      end
+
+      # The legacy flat key's value for +entry+, or nil.
+      def lookup_legacy(data, entry)
+        return nil unless entry && data.is_a?(Hash)
+
+        [entry.env_key, *Array(entry.aliases)].each do |key|
+          return data[key] if data.key?(key)
+          return data[key.to_sym] if data.key?(key.to_sym)
         end
+        nil
+      end
+
+      # The nested key's value for +yaml_path+, or nil.
+      def lookup_nested(data, yaml_path, entry = nil)
         cur = data
         yaml_path.each_with_index do |seg, idx|
           return nil unless cur.is_a?(Hash)
@@ -380,26 +409,98 @@ module Samagotchi
         reload!(cli_overrides: overrides)
       end
 
-      # Validation for top-level sections
+      # Problems with the keys of a parsed config.yml, one message per key the
+      # code doesn't read (with a "did you mean" when a known key is close).
+      # Every config-exposed entry in ENTRIES is known as written; names under
+      # the maps are the user's, and host/model entries may hold the keys
+      # their readers take. Legacy flat keys warn in ConfigFile.load_global_env!.
       def validate_yaml_sections(data)
         return [] unless data.is_a?(Hash)
-        errors = []
-        # Legacy flat UPPER keys are handled separately — don't flag them here
-        legacy_keys = BY_ENV.keys
-        data.each_key do |k|
-          next if %w[hosts hooks model_aliases models guardrails bundles].include?(k.to_s)
-          next if legacy_keys.include?(k.to_s)
-          # Sections are top-level keys that map to hashes (e.g., default, recap)
-          # If key contains _ or -, suggest dotted form
-          if k.to_s.include?("_")
-            errors << "top-level key '#{k}' contains '_' — use nested form '#{k.to_s.tr('_', '.')}' (e.g., default.model)"
+
+        data.flat_map do |key, value|
+          key = key.to_s
+          if find_by_env(key)&.config_exposed? || FREE_FORM_MAPS.include?(key) || REMOVED_KEYS.include?(key)
+            []
+          elsif MAP_ENTRY_KEYS.key?(key)
+            map_entry_problems(key, value)
+          elsif value.is_a?(Hash) && (known_sections.include?(key) || ENTRIES.any? { |e| e.yaml_path.size > 1 && e.section == key })
+            value.keys.filter_map { |leaf| key_problem("#{key}.#{leaf}") }
+          elsif known_sections.include?(key)
+            # An all-commented section is nil; recap: false turns recaps off.
+            value.nil? || (key == "recap" && value == false) ? [] : ["config: '#{key}' must be a mapping of settings; ignored"]
+          else
+            [key_problem(key)].compact
           end
-          # Check section name shape if its value is a Hash
-          if data[k].is_a?(Hash) && k.to_s.match?(/[_-]/)
-            errors << "section '#{k}' must match #{SECTION_RE.inspect} (no _ or -)"
+        end
+      end
+
+      # Dotted keys config.yml may set: config-exposed entries (snake and kebab
+      # leaf, yaml_aliases), the extra section keys and the map names.
+      def known_config_keys
+        @known_config_keys ||= ENTRIES.select(&:config_exposed?).flat_map do |entry|
+          *section, leaf = entry.yaml_path
+          [leaf, leaf.tr("_", "-"), *Array(entry.yaml_aliases)].map { |l| [*section, l].join(".") }
+        end.to_set.merge(SECTION_EXTRA_KEYS.flat_map { |s, leaves| leaves.map { |l| "#{s}.#{l}" } })
+                                .merge(FREE_FORM_MAPS).merge(MAP_ENTRY_KEYS.keys).freeze
+      end
+
+      private
+
+      def known_sections
+        @known_sections ||= known_config_keys.filter_map { |k| k.split(".").first if k.include?(".") }.to_set.freeze
+      end
+
+      # nil when +dotted+ is a key the file may hold.
+      def key_problem(dotted)
+        return nil if known_config_keys.include?(dotted)
+
+        entry = find_by_key(dotted) || find_by_env(dotted)
+        if entry
+          where = entry.cli_exposed? ? "#{entry.env_key} or #{entry.cli_flag}" : entry.env_key
+          return "config: '#{dotted}' can't be set in config.yml; use #{where}"
+        end
+
+        canonical = ENTRIES.select(&:config_exposed?).map(&:key) + known_sections.to_a +
+                    SECTION_EXTRA_KEYS.flat_map { |s, leaves| leaves.map { |l| "#{s}.#{l}" } } + FREE_FORM_MAPS + MAP_ENTRY_KEYS.keys
+        # A legacy-looking flat key compares by its nested form.
+        probe = dotted.start_with?("SAMAGOTCHI_") ? dotted.delete_prefix("SAMAGOTCHI_").downcase : dotted
+        unknown_key_message(dotted, probe, canonical)
+      end
+
+      def map_entry_problems(map, value)
+        return [] unless value.is_a?(Hash)
+
+        allowed = MAP_ENTRY_KEYS.fetch(map)
+        value.flat_map do |name, entry|
+          next [] unless entry.is_a?(Hash)
+
+          (entry.keys.map(&:to_s) - allowed).map do |k|
+            unknown_key_message("#{map}.#{name}.#{k}", k, allowed, prefix: "#{map}.#{name}.")
+          end
+        end
+      end
+
+      # "config: unknown key 'x'", with a "did you mean" naming the candidates
+      # within edit distance 2 of +probe+ (closest first) and the ones that
+      # share its last segment, at most three.
+      def unknown_key_message(key, probe, candidates, prefix: "")
+        candidates = candidates.uniq
+        near = candidates.map { |c| [levenshtein(probe, c), c] }.select { |d, _| d <= 2 }.sort.map(&:last)
+        close = (near + candidates.select { |c| c.split(".").last == probe.split(".").last }).uniq.first(3)
+        hint = close.empty? ? "" : " (did you mean #{close.map { |c| "'#{prefix}#{c}'" }.join(' or ')}?)"
+        "config: unknown key '#{key}'#{hint}"
+      end
+
+      def levenshtein(a, b)
+        prev = (0..b.size).to_a
+        a.each_char.with_index(1) do |ca, i|
+          cur = [i]
+          b.each_char.with_index(1) do |cb, j|
+            cur << [prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (ca == cb ? 0 : 1)].min
           end
+          prev = cur
         end
-        errors
+        prev.last
       end
     end
   end
@@ -467,6 +568,43 @@ module Samagotchi
       nil
     end
 
+    # Request keys chi sets itself; a `sampling:` map can't override them.
+    # (Length caps would need their own semantics.)
+    SAMPLING_RESERVED_KEYS = %w[model messages prompt stream stream_options tools tool_choice stop n_predict
+                                max_tokens n parallel_tool_calls response_format cache_prompt].freeze
+
+    # A `sampling:` setting (hosts entry or models: entry): request parameters
+    # passed through to the provider as written (keys symbolized, nested maps
+    # too, so e.g. chat_template_kwargs works). A null value means "don't
+    # send it" (drops chi's own temperature default). Not a map: warns once,
+    # nil. Reserved keys warn once and are dropped. nil when nothing is left.
+    def sampling_map(value, where)
+      return nil if value.nil?
+      unless value.is_a?(Hash)
+        warn_once "Warning: #{where}: sampling must be a map of request parameters; ignored"
+        return nil
+      end
+
+      result = value.each_with_object({}) do |(raw_key, raw_value), acc|
+        key = raw_key.to_s.strip
+        next if key.empty?
+        if SAMPLING_RESERVED_KEYS.include?(key)
+          warn_once "Warning: #{where}: sampling.#{key} is set by chi; ignored"
+          next
+        end
+        acc[key.to_sym] = deep_symbolize(raw_value)
+      end
+      result.empty? ? nil : result.freeze
+    end
+
+    def deep_symbolize(value)
+      case value
+      when Hash then value.to_h { |k, v| [k.to_s.to_sym, deep_symbolize(v)] }.freeze
+      when Array then value.map { |v| deep_symbolize(v) }.freeze
+      else value
+      end
+    end
+
     # Forget the warnings already printed (specs).
     def reset_warnings!
       @warned = nil
@@ -492,11 +630,18 @@ module Samagotchi
       existed = File.file?(path)
       raw = read_yaml(env: env, path: path) || {}
       if existed
-        Samagotchi::Config.validate_yaml_sections(raw).each { |w| Log.warn(:config, "invalid_section", echo: "Warning: #{w}") }
-        # Warn on legacy UPPER keys
+        Samagotchi::Config.validate_yaml_sections(raw).each { |w| Log.warn(:config, "config_key", echo: "Warning: #{w}") }
+        # Warn on legacy UPPER keys; the nested key wins when both are set.
+        # Any other flat key is unknown to validate_yaml_sections.
         raw.each_key do |k|
-          if k.to_s.match?(/\A[A-Z_]{2,}\z/) && k.to_s.start_with?("SAMAGOTCHI_")
-            Log.warn(:config, "legacy_key", echo: "Warning: config key '#{k}' is legacy UPPER — use '#{k.to_s.downcase.sub(/^samagotchi_/, '').tr('_', '.')}' (e.g., default.model)", key: k.to_s)
+          entry = Samagotchi::Config.find_by_env(k)
+          next unless entry&.config_exposed?
+
+          if !Samagotchi::Config.lookup_nested(raw, entry.yaml_path, entry).nil?
+            nested = entry.yaml_path.join(".")
+            Log.warn(:config, "legacy_key", echo: "Warning: config: both '#{k}' and '#{nested}' are set; using '#{nested}', remove the flat key", key: k.to_s)
+          else
+            Log.warn(:config, "legacy_key", echo: "Warning: config key '#{k}' is legacy UPPER — use '#{entry.yaml_path.join('.')}'", key: k.to_s)
           end
         end
       end
@@ -580,6 +725,7 @@ module Samagotchi
           profile = (raw_cfg["profile"] || raw_cfg[:profile]).to_s.strip.downcase
           first_token_timeout = raw_cfg.key?("first_token_timeout") ? raw_cfg["first_token_timeout"] : raw_cfg[:first_token_timeout]
           vision = ConfigFile.vision_flag(raw_cfg.key?("vision") ? raw_cfg["vision"] : raw_cfg[:vision], "hosts entry '#{name}'")
+          sampling = ConfigFile.sampling_map(raw_cfg.key?("sampling") ? raw_cfg["sampling"] : raw_cfg[:sampling], "hosts entry '#{name}'")
           unless first_token_timeout.nil? || (first_token_timeout.is_a?(Numeric) && !first_token_timeout.negative?)
             warn_once "Warning: hosts entry '#{name}': first_token_timeout must be seconds (0 = off); using the default"
             first_token_timeout = nil
@@ -643,7 +789,7 @@ module Samagotchi
                                   api: api_val&.to_sym, original_name: name, scheme: scheme,
                                   url: url.empty? ? nil : url, api_key_env: api_key_env.empty? ? nil : api_key_env,
                                   profile: profile.empty? ? nil : profile, first_token_timeout: first_token_timeout,
-                                  vision: vision }
+                                  vision: vision, sampling: sampling }
         end
       end
 
@@ -746,7 +892,7 @@ module Samagotchi
         location = v[:url] ? { "url" => v[:url] } : { "host" => v[:host], "port" => v[:port] }
         location.merge("transport" => v[:transport]&.to_s, "api" => v[:api]&.to_s, "api_key_env" => v[:api_key_env],
                        "profile" => v[:profile], "first_token_timeout" => v[:first_token_timeout],
-                       "vision" => v[:vision]).compact
+                       "vision" => v[:vision], "sampling" => v[:sampling]).compact
       end
       JSON.generate(simple)
     rescue StandardError
@@ -828,11 +974,25 @@ module Samagotchi
         vision = vision_flag(v.key?("vision") ? v["vision"] : v[:vision], "models: #{key}")
         result[key] = { profile: profile.empty? ? nil : profile }
         result[key][:vision] = vision unless vision.nil?
+        sampling = sampling_map(v.key?("sampling") ? v["sampling"] : v[:sampling], "models: #{key}")
+        result[key][:sampling] = sampling if sampling
       end
     rescue StandardError
       {}
     end
 
+    # The first +names+ (model as typed, alias-resolved, bare, …) whose
+    # models: entry sets +field+: [key, value], or nil. VisionSupport and
+    # SamplingSettings look a model up the same way.
+    def model_setting(names, field, models: nil)
+      models ||= model_settings
+      Array(names).map { |name| name.to_s.strip.downcase }.reject(&:empty?).uniq.each do |key|
+        value = models.dig(key, field)
+        return [key, value] unless value.nil?
+      end
+      nil
+    end
+
     def resolve_model_alias(raw, env: ENV, path: global_path(env: env), hosts: nil)
       value = raw.to_s.strip
       return value if value.empty?

data/lib/samagotchi/desktop/macos/ChiRunner.swift

@@ -49,18 +49,24 @@ struct LiveSession: Decodable, Identifiable, Equatable {
   /// Only UUID-shaped ids go into chi's argv, so nothing can turn into a flag.
   var valid: Bool { UUID(uuidString: id) != nil }
 
-  var shortCwd: String {
-    guard let cwd else { return "" }
+  var shortCwd: String { cwd.map(Self.shorten) ?? "" }
+
+  /// A path with the home folder as "~".
+  static func shorten(_ path: String) -> String {
     let home = NSHomeDirectory()
-    return cwd.hasPrefix(home) ? "~" + cwd.dropFirst(home.count) : cwd
+    return path.hasPrefix(home) ? "~" + path.dropFirst(home.count) : path
   }
 
-  /// "just now", "5m ago", "2h ago", "yesterday", "3d ago", or "".
-  func age(now: Date = Date()) -> String {
-    guard let updatedAt else { return "" }
+  var updated: Date? {
+    guard let updatedAt else { return nil }
     let precise = ISO8601DateFormatter()
     precise.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
-    guard let date = precise.date(from: updatedAt) ?? ISO8601DateFormatter().date(from: updatedAt) else { return "" }
+    return precise.date(from: updatedAt) ?? ISO8601DateFormatter().date(from: updatedAt)
+  }
+
+  /// "just now", "5m ago", "2h ago", "yesterday", "3d ago", or "".
+  func age(now: Date = Date()) -> String {
+    guard let date = updated else { return "" }
     let seconds = max(0, now.timeIntervalSince(date))
     switch seconds {
     case ..<60: return "just now"

data/lib/samagotchi/desktop/macos/Panel.swift

@@ -1,6 +1,7 @@
 // The Spotlight-like panel: a message line on top, the text (selection or
-// clipboard) below it as quoted context, then the sessions. ⏎ sends a
-// message (`chi send`), ⌘⏎ a note (`chi note`), ⇧⏎ is a newline.
+// clipboard) below it as quoted context, then a "New session" row and the
+// sessions. ⏎ sends a message (`chi send`, or `chi send --new` on the new
+// row), ⌘⏎ a note (`chi note`), ⇧⏎ is a newline.
 import AppKit
 import SwiftUI
 
@@ -16,6 +17,8 @@ final class PanelModel: ObservableObject {
   @Published var source = ""
   @Published var sessions: [LiveSession] = []
   @Published var selected: Set<String> = []
+  /// The "New session" row; never together with sessions (`--new` takes no ids).
+  @Published var newSelected = false
   @Published var phase: Phase = .loading
   @Published var message = ""
 
@@ -28,21 +31,45 @@ final class PanelModel: ObservableObject {
   var trimmedPrompt: String { prompt.trimmingCharacters(in: .whitespacesAndNewlines) }
   var hasContext: Bool { !text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
   var sendEnabled: Bool {
-    canSend && !selected.isEmpty && (!trimmedPrompt.isEmpty || hasContext)
+    canSend && (newSelected || !selected.isEmpty) && (!trimmedPrompt.isEmpty || hasContext)
   }
   var live: [LiveSession] { sessions.filter { !$0.recent } }
   var recent: [LiveSession] { sessions.filter(\.recent) }
 
-  /// The last choice, where still live; else the only live session. A
-  /// recent (stopped) one is never preselected: a message would wake it.
+  /// The last choice, where still live; else the only live session; else,
+  /// with none live, the new row. A recent (stopped) one is never
+  /// preselected: a message would wake it.
   func preselect() {
     let last = Set(UserDefaults.standard.stringArray(forKey: Self.lastChoiceKey) ?? [])
     selected = last.intersection(Set(live.map(\.id)))
     if selected.isEmpty, live.count == 1 { selected = [live[0].id] }
+    newSelected = live.isEmpty
   }
 
   func toggle(_ id: String) {
-    if selected.contains(id) { selected.remove(id) } else { selected.insert(id) }
+    if selected.contains(id) { selected.remove(id) } else { selected.insert(id); newSelected = false }
+  }
+
+  func toggleNew() {
+    newSelected.toggle()
+    if newSelected { selected = [] }
+  }
+
+  /// Where a new session starts: the helper runs in $HOME, which is in no
+  /// project, so the folder of the most recently updated live session, else
+  /// of the newest recent one, else home.
+  var newSessionDir: String {
+    let exists = { (s: LiveSession) -> Bool in
+      var dir: ObjCBool = false
+      return s.cwd.map { FileManager.default.fileExists(atPath: $0, isDirectory: &dir) && dir.boolValue } ?? false
+    }
+    let newest = { (list: [LiveSession]) in list.filter(exists).max { ($0.updated ?? .distantPast) < ($1.updated ?? .distantPast) } }
+    return (newest(live) ?? newest(recent))?.cwd ?? NSHomeDirectory()
+  }
+
+  var newSessionFolder: String {
+    let dir = newSessionDir
+    return dir == NSHomeDirectory() ? "~" : (dir as NSString).lastPathComponent
   }
 
   /// In list order, only ids that are live and UUID-shaped.
@@ -103,10 +130,7 @@ struct PanelView: View {
           Text("Looking for live sessions…").foregroundColor(.secondary)
         }.padding(10)
       default:
-        if model.sessions.isEmpty {
-          Text(model.phase == .failed && !model.message.isEmpty ? "" : "No live or recent sessions. Start one with `chi` in a terminal.")
-            .foregroundColor(.secondary).padding(10)
-        }
+        newRow
         ForEach(Array(model.sessions.prefix(9).enumerated()), id: \.element.id) { index, session in
           if session.recent && index == model.live.count {
             HStack(spacing: 6) {
@@ -123,6 +147,28 @@ struct PanelView: View {
     .frame(maxWidth: .infinity, alignment: .leading)
   }
 
+  var newRow: some View {
+    let on = model.newSelected
+    return Button(action: { model.toggleNew() }) {
+      HStack(spacing: 10) {
+        Image(systemName: on ? "plus.circle.fill" : "plus.circle")
+          .font(.system(size: 16))
+          .foregroundColor(on ? .accentColor : .secondary)
+        VStack(alignment: .leading, spacing: 1) {
+          Text("New session in \(model.newSessionFolder)").font(.system(size: 13, weight: .medium)).lineLimit(1)
+          Text(LiveSession.shorten(model.newSessionDir)).font(.system(size: 11)).foregroundColor(.secondary).lineLimit(1)
+        }
+        Spacer()
+        Text("⌘0").font(.system(size: 11, design: .rounded)).foregroundColor(.secondary)
+      }
+      .padding(.horizontal, 8).padding(.vertical, 6)
+      .background(RoundedRectangle(cornerRadius: 7).fill(on ? Color.accentColor.opacity(0.14) : Color.clear))
+      .contentShape(Rectangle())
+    }
+    .buttonStyle(.plain)
+    .help("start a session with the message, as the web does (chi send --new); a note needs a session")
+  }
+
   func row(_ session: LiveSession, index: Int) -> some View {
     let on = model.selected.contains(session.id)
     return Button(action: { model.toggle(session.id) }) {
@@ -274,12 +320,12 @@ final class PanelController: NSObject, NSWindowDelegate {
     return true
   }
 
-  /// ⌘1…⌘9 toggle a session.
+  /// ⌘1…⌘9 toggle a session, ⌘0 the new row.
   private func handleKey(_ event: NSEvent) -> Bool {
     guard event.modifierFlags.intersection(.deviceIndependentFlagsMask) == .command,
-          let chars = event.charactersIgnoringModifiers, let n = Int(chars), (1...9).contains(n),
+          let chars = event.charactersIgnoringModifiers, let n = Int(chars),
           n <= model.sessions.count else { return false }
-    model.toggle(model.sessions[n - 1].id)
+    if n == 0 { model.toggleNew() } else { model.toggle(model.sessions[n - 1].id) }
     return true
   }
 
@@ -290,6 +336,7 @@ final class PanelController: NSObject, NSWindowDelegate {
     model.text = text
     model.source = source
     model.message = ""
+    model.newSelected = false
     model.phase = .loading
     placeOnActiveScreen()
     panel.makeKeyAndOrderFront(nil)
@@ -323,10 +370,14 @@ final class PanelController: NSObject, NSWindowDelegate {
 
   func send(_ kind: SendKind) {
     let ids = model.selectedIds
-    guard model.sendEnabled, !ids.isEmpty else { NSSound.beep(); return }
+    let new = model.newSelected
+    // A note into a session that doesn't exist yet makes no sense.
+    guard model.sendEnabled, new ? kind == .message : !ids.isEmpty else { NSSound.beep(); return }
     model.phase = .sending
     model.message = ""
-    UserDefaults.standard.set(ids.filter { id in model.live.contains { $0.id == id } }, forKey: PanelModel.lastChoiceKey)
+    if !new {
+      UserDefaults.standard.set(ids.filter { id in model.live.contains { $0.id == id } }, forKey: PanelModel.lastChoiceKey)
+    }
     let prompt = model.trimmedPrompt
     let command: String
     var args: [String]
@@ -335,7 +386,7 @@ final class PanelController: NSObject, NSWindowDelegate {
     case .message:
       // stdin is the quoted context; without -m, chi takes it as the message.
       command = "chi send"
-      args = ["send"]
+      args = new ? ["send", "--new", "--dir", model.newSessionDir] : ["send"]
       if !prompt.isEmpty { args += ["-m", prompt] }
       stdin = model.hasContext ? Data(model.text.utf8) : nil
     case .note:
@@ -346,7 +397,7 @@ final class PanelController: NSObject, NSWindowDelegate {
       let parts = [prompt, model.hasContext ? model.text : ""].filter { !$0.isEmpty }
       stdin = Data(parts.joined(separator: "\n\n").utf8)
     }
-    args += ids
+    if !new { args += ids }
     runner.run(args, stdin: stdin) { [weak self] result in
       guard let self else { return }
       switch result {
@@ -362,9 +413,10 @@ final class PanelController: NSObject, NSWindowDelegate {
           self.model.message = "\(command) took over \(Int(self.runner.timeout)) s and was stopped; \(what). \(out)"
         } else if r.status == 0 {
           self.model.phase = .sent
-          self.model.message = out.isEmpty ? "Sent." : out
+          // --new prints "<full id>  started".
+          self.model.message = out.isEmpty ? "Sent." : new ? "started \(out.prefix(8))…" : out
           // Long enough to read a "waits for the session's next start" line.
-          let linger = out.contains("waits for") || out.contains("started its worker") ? 3.0 : 1.0
+          let linger = out.contains("waits for") || out.contains("started") ? 3.0 : 1.0
           DispatchQueue.main.asyncAfter(deadline: .now() + linger) { [weak self] in
             if self?.model.phase == .sent { self?.panel.close() }
           }

data/lib/samagotchi/empty_answer_retry.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "config"
+require_relative "turn_note"
+
+module Samagotchi
+  # Asking the model again, in the same turn, when a generation ends with no
+  # visible text and no tool calls (thinking only, or nothing): a hidden
+  # nudge (TurnNote.empty_retry), then another generation. Both loops use
+  # it; the Engine's TurnNote.empty is what's left when the retries run out.
+  module EmptyAnswerRetry
+    MAX = 3
+    # Greedy decoding on a near-identical prompt would likely loop again:
+    # the retry runs at this temperature unless one is configured.
+    TEMPERATURE = 0.6
+    # A generation cut at the provider's output cap (finish_reason length)
+    # is retried unless the context is this full.
+    CONTEXT_FULL_RATIO = 0.9
+
+    module_function
+
+    # retry.empty_answer, 0..MAX.
+    def limit
+      Config.get("retry.empty_answer").to_i.clamp(0, MAX)
+    rescue StandardError
+      1
+    end
+
+    # The request options of a retry generation: the turn's sampling, with
+    # TEMPERATURE when it sets none (a configured nil keeps "don't send").
+    def sampling(base)
+      base = base || {}
+      base.key?(:temperature) ? base : base.merge(temperature: TEMPERATURE)
+    end
+
+    # The prompt filled the window (a length stop is then no loop to break).
+    def context_full?(used_tokens, window_tokens)
+      return false unless used_tokens.to_i.positive? && window_tokens.to_i.positive?
+
+      used_tokens.to_f / window_tokens >= CONTEXT_FULL_RATIO
+    end
+  end
+end