samagotchi 0.148.0 → 0.150.0

data/lib/samagotchi/update_command.rb

@@ -9,6 +9,7 @@ require_relative "desktop"
 require_relative "gem_update"
 require_relative "installed_gem"
 require_relative "live_versions"
+require_relative "memory_bundle/file_standing"
 require_relative "memory_bundle/shipped_update"
 require_relative "memory_bundle/system_bundle"
 require_relative "session"
@@ -20,8 +21,8 @@ require "json"
 module Samagotchi
   # `chi update`: brings an installed chi up to date in one go: the system
   # bundle, the shipped bundles the user installed, and the macOS helper.
-  # Unedited things update; edited ones are kept (.md) or replaced and
-  # reported (hooks, plugin, rules, which didn't load once edited). Live
+  # Unedited things update; edited ones merge or stay behind (.md) or are replaced
+  # and reported (hooks, plugin, rules, which didn't load once edited). Live
   # workers and a running chi web are reported, never restarted. The bundles
   # chi didn't ship are only checked, under the chi that will run them
   # (BundleCommand::InstalledCheck): what it finds is rows that fail nothing.
@@ -34,10 +35,15 @@ module Samagotchi
         Updates this chi's install: the gem (from rubygems.org), then the
         system bundle, the bundles chi ships that you installed (chi bundle
         list), and the desktop helper (macOS; rebuilt only when its sources
-        changed). Edited memory files are kept and reported; nothing is
-        installed that isn't already, and old gem versions stay. The bundles
-        chi doesn't ship are never changed: the new chi checks them and adds
-        a row per warning or error (these don't fail the update).
+        changed). A memory file you edited takes the update in a text merge
+        (the old file goes to the bundle trash), or stays behind as it is when
+        no merge is possible, and the table says which and why; each run
+        retries a file left behind, though one an older chi marked, with a base
+        no installed chi shipped, merges only if the bundle takes out or rewords
+        no line it still holds. Nothing is
+        installed that isn't already, and old gem versions stay. The bundles chi doesn't ship are
+        never changed: the new chi checks them and adds a row per warning or
+        error (these don't fail the update).
         --dry-run      show what would change; change nothing (with a newer
                        gem to install, bundles chi doesn't ship aren't checked:
                        that chi would)
@@ -76,8 +82,11 @@ module Samagotchi
 
     # A table row. info rows (live workers, chi web) say what runs; they
     # never fail. level ("warn", "error"; else nil) marks a finding on a bundle
-    # chi didn't ship: it reports, changes nothing and fails nothing.
-    Row = Struct.new(:component, :from, :to, :status, :failed, :kept, :level, keyword_init: true)
+    # chi didn't ship: it reports, changes nothing and fails nothing. kept: the
+    # memory files that stay behind; merged: the ones that took the update;
+    # trash_copy: where their old copies went, in full (the table's short: --json
+    # has the path); earlier: the files of the earlier merges the row names.
+    Row = Struct.new(:component, :from, :to, :status, :failed, :kept, :merged, :earlier, :trash_copy, :level, keyword_init: true)
 
     # What a row says after a change, and in a dry run.
     VERBS = { update: ["updated", "would update"], install: ["installed", "would install"],
@@ -95,6 +104,7 @@ module Samagotchi
                    gem_update: nil, exec: nil, bundler: nil, home: ChiHome, env: ENV)
       @home = home
       @in_home = env.delete(IN_HOME_ENV) == "1"
+      @unattended = env[ChildEnv::UNATTENDED_UPDATE] == "1"
       # Built after the home is known: its install env goes into the home.
       @gem_update_given = gem_update
       @exec = exec || ->(argv) { Kernel.exec(*argv) }
@@ -147,7 +157,7 @@ module Samagotchi
       gem = gem_row(options)
       rows = [gem, system_bundle_row, *bundle_rows(options), *external_rows(options), desktop_row(options), *live_rows].compact
       if options[:json]
-        @stdout.puts(JSON.generate(rows.map { |row| row.to_h.merge(failed: !!row.failed, kept: row.kept || []) }))
+        @stdout.puts(JSON.generate(rows.map { |row| row.to_h.merge(failed: !!row.failed, kept: row.kept || [], merged: row.merged || [], earlier: row.earlier || []) }))
       else
         print_table(rows)
         footers(options, rows).each { |line| @stdout.puts(line) }
@@ -279,17 +289,24 @@ module Samagotchi
     end
 
     def system_bundle_row
-      result = MemoryBundle::SystemBundle.sync(dry_run: @dry_run)
+      system = MemoryBundle::SystemBundle
+      earlier = system.merge_notes
+      result = system.sync(dry_run: @dry_run)
+      # These rows have no place for the notes, which wait for one that has.
+      earlier = [] if %i[installed skipped failed].include?(result.status)
       row = Row.new(component: "system bundle", from: result.from, to: result.to)
+      notes = file_notes(row, system::BUNDLE_NAME, result.to, result.merged, result.behind, result.trash_copy, earlier: earlier)
       case result.status
       when :installed then done(row, :install)
-      when :updated then done(row, :update, kept(row, result.kept, MemoryBundle::SystemBundle::BUNDLE_NAME))
-      when :restored then done(row, :restore).tap { |r| r.to = nil }
-      when :up_to_date then up_to_date(row)
-      when :newer_installed then skipped(row, "newer than this chi's #{result.to}: left").tap { |r| r.to = nil }
+      when :updated then done(row, :update, notes.empty? ? nil : notes.join("; "))
+      when :restored then done(row, :restore, notes.empty? ? nil : notes.join("; ")).tap { |r| r.to = nil }
+      when :merged, :up_to_date then same_version(row, notes + result.warnings, changed: result.merged.any?)
+      when :newer_installed then skipped(row, ["newer than this chi's #{result.to}: left", *notes].join("; ")).tap { |r| r.to = nil }
       when :skipped then skipped(row, result.error)
       else failed(row, result.error)
       end
+      system.clear_merge_notes(earlier, files: result.merged) if read_by_someone?
+      row
     end
 
     def bundle_rows(options)
@@ -320,14 +337,50 @@ module Samagotchi
 
     def bundle_row(update)
       row = Row.new(component: update.name, from: update.from, to: update.to)
+      earlier = update.status == :failed ? [] : Array(update.earlier)
+      notes = file_notes(row, update.name, update.to || update.from, update.merged, update.behind, update.trash_copy, earlier: earlier)
       case update.status
       when :would_update, :updated
-        notes = [adds(update.adds), kept(row, update.kept, update.name), replaced(update.replaced), *update.kept_own].compact
+        notes = [adds(update.adds), *notes, replaced(update.replaced), *update.kept_own].compact
         done(row, :update, notes.empty? ? nil : notes.join("; "))
-      when :up_to_date then up_to_date(row)
-      when :skipped then skipped(row, update.note)
-      else failed(row, update.note)
+      when :would_merge, :merged, :up_to_date then same_version(row, [*notes, update.note].compact, changed: Array(update.merged).any?)
+      when :skipped then skipped(row, [update.note, *notes].join("; "))
+      else failed(row, [update.note, *notes].compact.join("; "))
       end
+      # A failed row keeps them: the run didn't finish, and the next says what stands.
+      MemoryBundle::Provenance.new(name: update.name).clear_merge_notes(earlier, files: row.merged) if read_by_someone? && update.status != :failed
+      row
+    end
+
+    # What one bundle's memory files did, in FileStanding's words; the row keeps
+    # the file names and the trash copy's full line for --json. merged is what
+    # this run merged, earlier the files of the notes it shows.
+    # @return [Array<String>] the row's clauses
+    def file_notes(row, bundle, version, merged, behind, trash_copy, earlier: [])
+      merged = Array(merged)
+      behind = Array(behind)
+      row.merged = merged
+      row.earlier = earlier.map(&:file)
+      row.kept = behind.map(&:file)
+      @unsure_behind ||= behind.any?(&:unsure)
+      row.trash_copy = trash_copy
+      notes = MemoryBundle::FileStanding.clauses(bundle, version, merged: merged, behind: behind, earlier: earlier, dry_run: @dry_run)
+      trash_copy || earlier.any?(&:trash) ? [*notes, MemoryBundle::FileStanding::IN_THE_TRASH] : notes
+    end
+
+    # Whether a row printed now ends the notes for what it printed, this run's
+    # merges too. A dry run changes nothing, and an automatic update's rows may be
+    # read by no one (ChildEnv::UNATTENDED_UPDATE).
+    def read_by_someone? = !@dry_run && !@unattended
+
+    # A row at the same version: up to date only when nothing merged and nothing
+    # stays behind. No to, and no verb of its own: the clauses say it all.
+    def same_version(row, notes, changed:)
+      return up_to_date(row, notes.join("; ")) unless changed || row.kept.any?
+
+      row.to = nil
+      row.status = notes.join("; ")
+      row
     end
 
     def desktop_row(options)
@@ -420,6 +473,9 @@ module Samagotchi
       return "(dry run: nothing was changed)" if @dry_run
       return "some parts failed (see above)" if rows.any?(&:failed)
 
+      behind = rows.sum { |row| Array(row.kept).size }
+      return "#{MemoryBundle::FileStanding.stay_behind(behind, unsure: @unsure_behind)} (see above)" if behind.positive?
+
       # A finding on a bundle chi didn't ship repeats until its bundle changes; it isn't a change.
       changes = rows.reject(&:level)
       changes.all? { |r| r.status.start_with?("up to date", "skipped", "not installed", "couldn't check") } ? "everything is up to date" : "done"
@@ -434,9 +490,9 @@ module Samagotchi
       row
     end
 
-    def up_to_date(row)
+    def up_to_date(row, note = nil)
       row.to = nil
-      row.status = "up to date"
+      row.status = note.to_s.empty? ? "up to date" : "up to date (#{note})"
       row
     end
 
@@ -456,14 +512,6 @@ module Samagotchi
       members.nil? || members.empty? ? nil : "+ #{members.join(", ")}"
     end
 
-    def kept(row, files, bundle)
-      row.kept = files.dup
-      return nil if row.kept.empty?
-
-      verb = @dry_run ? "would keep" : "kept"
-      "#{verb} your edits in #{row.kept.join(", ")}: chi bundle diff #{bundle} #{row.kept.first}"
-    end
-
     def replaced(files)
       return nil if files.empty?
 

data/lib/samagotchi/update_hint.rb

@@ -43,7 +43,10 @@ module Samagotchi
     end
 
     def message(version, shipped_dir:, helper:)
-      bundles = MemoryBundle::ShippedUpdate.plan(shipped_dir: shipped_dir).count { |r| r.status == :would_update }
+      # A retry that would merge is an update too; one that only records a reason isn't.
+      bundles = MemoryBundle::ShippedUpdate.plan(shipped_dir: shipped_dir).count do |r|
+        r.status == :would_update || (r.status == :would_merge && r.merged.any?)
+      end
       parts = []
       parts << (bundles == 1 ? "1 bundle" : "#{bundles} bundles") if bundles.positive?
       parts << "the desktop helper" if helper&.stale?

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.148.0"
+  VERSION = "0.150.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/auto_update.rb

@@ -197,7 +197,7 @@ module Samagotchi
       end
 
       # A newer chi this didn't install, settled: a run of its own from here.
-      # The terminal's table already told what `chi update` kept.
+      # The terminal's table already told what `chi update` merged or left behind.
       def adopt_installed
         return unless @restart == "idle" && @seen
 
@@ -215,10 +215,10 @@ module Samagotchi
         return Log.info(:web, "auto_update_deferred", version: version, why: result) if result.is_a?(Symbol)
 
         rows = result.rows
-        record = AutoUpdateRecord.new(version: version, from: VERSION, at: @clock.call.iso8601, kept: kept_files(rows),
-                                      phase: "installed")
+        record = AutoUpdateRecord.new(version: version, from: VERSION, at: @clock.call.iso8601, kept: files_in(rows, "kept"),
+                                      merged: files_in(rows, "merged"), phase: "installed")
         if result.done?
-          Log.info(:web, "auto_update_installed", version: version, kept: record.kept.size)
+          Log.info(:web, "auto_update_installed", version: version, kept: record.kept.size, merged: record.merged.size)
           installed(record)
         else
           failed(record, rows)
@@ -232,7 +232,7 @@ module Samagotchi
         return carry_on(save(record)) unless @restart == "never"
 
         save(record.with(phase: "done", pushed: true))
-        @hub.publish_notice(kind: "installed", version: record.version, kept: record.kept.size)
+        @hub.publish_notice(kind: "installed", version: record.version, kept: record.kept.size, merged: record.merged.size)
       end
 
       # The next step of a run on record.
@@ -328,7 +328,7 @@ module Samagotchi
         record = restart_workers(record) || record
         Log.info(:web, "auto_update_done", version: record.version, restarted: record.restarted, left: record.left)
         save(record.with(phase: record.left_to_try?(@clock.call, RETRY_FOR) ? RETRYING : "done", pushed: true))
-        @hub.publish_notice(kind: "updated", version: record.version, kept: record.kept.size,
+        @hub.publish_notice(kind: "updated", version: record.version, kept: record.kept.size, merged: record.merged.size,
                             restarted: record.restarted, left: record.left)
       end
 
@@ -366,8 +366,8 @@ module Samagotchi
                             installed: gem_installed)
       end
 
-      def kept_files(rows)
-        rows.flat_map { |row| Array(row["kept"]).map(&:to_s) }.uniq
+      def files_in(rows, field)
+        rows.flat_map { |row| Array(row[field]).map(&:to_s) }.uniq
       end
     end
   end

data/lib/samagotchi/web/auto_update_record.rb

@@ -13,8 +13,10 @@ module Samagotchi
     # +phase+: installed, workers, web (AutoUpdate::OPEN_PHASES), retrying,
     # done or failed. +restarted+ and +left+ count the stale workers (`workers` in
     # the file); +at+ is when the install ended, an ISO 8601 string.
-    AutoUpdateRecord = Data.define(:version, :from, :at, :kept, :phase, :restarted, :left, :detail, :pushed) do
-      def initialize(version:, phase:, from: nil, at: nil, kept: [], restarted: 0, left: 0, detail: nil, pushed: false)
+    # +kept+ and +merged+ name the edited memory files that stayed behind and
+    # that took the update (chi update --json's).
+    AutoUpdateRecord = Data.define(:version, :from, :at, :kept, :merged, :phase, :restarted, :left, :detail, :pushed) do
+      def initialize(version:, phase:, from: nil, at: nil, kept: [], merged: [], restarted: 0, left: 0, detail: nil, pushed: false)
         super
       end
 
@@ -30,14 +32,14 @@ module Samagotchi
 
         workers = hash["workers"].is_a?(Hash) ? hash["workers"] : {}
         new(version: version, phase: phase, from: hash["from"], at: hash["at"],
-            kept: Array(hash["kept"]).grep(String), restarted: workers["restarted"].to_i, left: workers["left"].to_i,
+            kept: Array(hash["kept"]).grep(String), merged: Array(hash["merged"]).grep(String), restarted: workers["restarted"].to_i, left: workers["left"].to_i,
             detail: hash["detail"], pushed: hash["pushed"] == true)
       end
 
       # What goes in the file, for .from_h to read back.
       # @return [Hash{String => Object}]
       def to_store
-        { "version" => version, "from" => from, "at" => at, "kept" => kept, "phase" => phase,
+        { "version" => version, "from" => from, "at" => at, "kept" => kept, "merged" => merged, "phase" => phase,
           "workers" => { "restarted" => restarted, "left" => left }, "detail" => detail,
           "pushed" => pushed ? true : nil }.compact
       end

data/lib/samagotchi/web/message_display.rb

@@ -7,6 +7,7 @@ require_relative "../context_note"
 require_relative "../image_store"
 require_relative "../message_parts"
 require_relative "../message_time"
+require_relative "../objectives"
 require_relative "../output_formatter"
 require_relative "../recap_store"
 require_relative "../ref"
@@ -95,11 +96,19 @@ module Samagotchi
         list = Array(msgs)
         # The outputs' ✂ marks (LLM context edits), by id, for the parts.
         marks = parts ? MessageParts.edit_marks(list) : {}
+        # The list before each objectives note, for what its entry says changed.
+        objectives = nil
         list.each_with_index do |m, index|
           role = (m[:role] || m["role"]).to_s
           content = (m[:content] || m["content"]).to_s
           if Samagotchi::ContextNote.note?(m)
             note = { role: "note", content: Samagotchi::ContextNote.text_of(m), label: Samagotchi::ContextNote.label_of(m), **time_of(m) }
+            payload = Samagotchi::ContextNote.fetch(m, :objectives)
+            entry = payload && Samagotchi::Objectives.entry(payload, before: objectives)
+            if entry
+              note[:objectives] = entry
+              objectives = Samagotchi::Objectives.from_payload(payload)
+            end
             # A context wake turn's note starts that turn (Steer.turn_prompt?):
             # the page opens the turn with it and pairs it with its record.
             if Samagotchi::Steer.turn_prompt?(m)

data/lib/samagotchi/web/participant_view.rb

@@ -82,10 +82,10 @@ module Samagotchi
         after_generation after_tool_call after_turn answer_display before_generation before_tool_call before_turn
         card command_output command_queued command_ran context_added context_status empty_answer_retry
         generation_cancelled generation_completed generation_progress generation_started guardrail_warning hook_notice
-        llm_context_edited merged_input participants_changed pending_input_merged plugin_init_finished
+        llm_context_edited merged_input objectives_updated participants_changed pending_input_merged plugin_init_finished
         plugin_init_started plugin_init_wait prompt_restored question question_relay reasoning_history_refused
         recap_ready reminder_injected sampling_refused session_end session_start side_usage steer_cut thinking_dropped
-        thinking_refused tool_dispatch_completed tool_dispatch_started used_memories_updated working_set_updated
+        thinking_refused tool_dispatch_completed tool_dispatch_started turn_rolled_back used_memories_updated working_set_updated
       ].freeze
 
       # A merged input line's saved sources a participant sees: a person's

data/lib/samagotchi/web/public/app.js

@@ -54,6 +54,7 @@ import { createBubbles, hintEl, outputBubbleTemplate } from "./bubbles.js";
 import { createCardsPlace } from "./cards_place.js";
 import { createStageView } from "./stage_view.js";
 import { createWorkingSet, groupItems } from "./working_set_view.js";
+import { createObjectives } from "./objectives_wiring.js";
 import { turnGroups } from "./timing.js";
 import { createGapClock, lastActivity } from "./time_gaps.js";
 import { createMarkdownPlace } from "./markdown_place.js";
@@ -421,6 +422,10 @@ const deliveryControl = createDeliveryControl({
 // This tab's id in the session's events: tells its own prompts from the
 // ones other clients (an attached TUI, another tab, reminders) sent.
 const clientId = newClientId();
+const objectives = createObjectives({
+  el: $("#objectivesStrip"), historyEl, session: () => store.selected, running: () => liveTurn.running, holding: () => turnDom.holds(), commands: () => store.current.commands,
+  clientId, sendCommand, sendTurn, follow: () => followWokenWorker(), toast: (...args) => showToast(...args),
+});
 // The question and continue cards in the history (question_cards.js).
 const questionCards = createQuestionCards({
   sessionId: () => store.selected,
@@ -1017,6 +1022,7 @@ function forgetSession({ keepVerify = false } = {}) {
   });
   commandList.close();
   resetTurnView();
+  objectives.reset();
   seedInitTasks(initTasks, []);
   renderInitRow();
   setMarkdownWarning(null);
@@ -1178,11 +1184,13 @@ function renderSessionView(data, { kept = [] } = {}) {
   if (data.messages && data.messages.length) renderHistory(data.messages);
   else renderHistory(data.history || []);
   seedWorkingSet(data);
+  objectives.seed(data.objectives);
   restoreCommandBubbles(historyEl, kept);
   // A failed turn's prompt went back to the user: shown after the
   // conversation, marked failed, as it was live (prompt_restored).
-  if (data.failed_turn) {
-    makeUserBubble(data.failed_turn.prompt, { state: "failed" }).dataset.failedTurn = "1";
+  const failedPrompt = data.failed_turn ? makeUserBubble(data.failed_turn.prompt, { state: "failed" }) : null;
+  if (failedPrompt) {
+    failedPrompt.dataset.failedTurn = "1";
     addEndBubble(failedTurnText(data.failed_turn));
   }
   seedSeenFromDom();
@@ -1196,7 +1204,8 @@ function renderSessionView(data, { kept = [] } = {}) {
   // A live worker's last cards and between-turns notices, where they
   // arrived; the running turn's go into its step once it is drawn.
   const snapshotCards = splitSnapshotCards(data.cards, pageCapabilities);
-  placeSnapshotCards(snapshotCards.placed);
+  // Above a failed turn's prompt: it came after them, and it is no turn.
+  placeSnapshotCards(snapshotCards.placed, { before: failedPrompt });
   // The recap saved with the session (also a stopped one's), else a live
   // worker's from before saved_recap existed. After the cards: the last
   // turn's check-in notice goes to the end, and the recap closes the page.
@@ -1761,6 +1770,8 @@ const streamHandlers = createStreamHandlers({
   // cards_place.js
   upsertCard, refreshCardBodies,
   syncModelPick: startPage.commandRan,
+  objectivesUpdated: (data) => objectives.update(data),
+  cardActionFailed: cards.actionFailed,
 });
 
 async function refreshTimingFromSession() {
@@ -2204,6 +2215,7 @@ store.on("settingsPanel", () => settingsControl.refresh());
 store.on("workingSetStrategy", () => workingSet?.strategyChanged());
 store.on("featureGates", () => featureGates.check(store.current));
 store.on("composer", updateComposerMode);
+store.on("composer", () => objectives.redraw());
 // The answers' Revise buttons follow liveTurn.running too (none on the
 // running turn's answer), which touches the composer.
 store.on("composer", () => reviseStacks.decorate());

data/lib/samagotchi/web/public/block_open.js

@@ -0,0 +1,13 @@
+// Whether a finished turn's steps block stays open: a completed turn's closes
+// to its summary line, whatever its steps said (opened, it shows the outline).
+// A canceled or failed turn with an outline stays open: its last narrated step
+// is the only text the reader gets. A "gone" end (the worker left) counts as
+// completed: its partial answer bubble carries the text, and a reload, which
+// can't tell it from one, draws the same. The live end, the stage's hand-off
+// and a reload all ask here.
+//
+// A module of its own: static JS is cached at unversioned URLs, and a new
+// export on an old module would blank the page.
+export function openAfterEnd(kind, outlined) {
+  return !!outlined && (kind === "canceled" || kind === "failed");
+}

data/lib/samagotchi/web/public/bubbles.js

@@ -26,8 +26,10 @@ export function removeQueuedBubble(bubble) {
   if (slot && slot.childElementCount === 0) slot.remove();
 }
 
-// A prompt that started a turn: not a line steered into a running one.
-export const TURN_PROMPT = ".bubble.user:not(.steered)";
+// A prompt that started a turn: not a line steered into a running one, nor a
+// failed turn's prompt, drawn again after the history (it went back to its
+// sender: the session and the turn count have no such turn).
+export const TURN_PROMPT = ".bubble.user:not(.steered):not(.failed)";
 
 // The history's turn prompts, oldest first (what turns_since counts).
 export function turnPromptBubbles(historyEl) {

data/lib/samagotchi/web/public/cards_place.js

@@ -46,8 +46,10 @@ export function turnAnswerEl(turnEls) {
 //   (bubbles.js createBubbles)
 // @param followWokenWorker () follows the worker a card's command woke
 // @param api {getSession, sendCommand} (data.js)
-// @return {cardElement(id), upsertCard(card, {before}), placeSnapshotCards(entries),
+// @return {cardElement(id), upsertCard(card, {before}), placeSnapshotCards(entries, {before}),
 //   refreshCardBodies(), onCardAction(event)}
+const HELD_UNTIL_ANSWERED = /^\/objectives --card /;
+
 export function createCardsPlace({
   historyEl, turnDom, findInTurnRoots, selected, clientId, questionCards, bubbles,
   followWokenWorker, api = { getSession, sendCommand },
@@ -61,9 +63,12 @@ export function createCardsPlace({
   // running turn's card as a row of its step; else before +before+ or at the
   // end of the history). A running turn's card with actions asks the user
   // something (check-in's Nudge / Keep going / Stop): it goes under the turn's
-  // block, not into a step that collapses when the next one starts.
+  // block, not into a step that collapses when the next one starts. A turn
+  // still sliding away arrives first: its list of pieces holds this card's
+  // element, and an update may swap that (drawCard, a notice to a card).
   function upsertCard(card, { before = null } = {}) {
     if (!card || !card.id) return;
+    turnDom.settleFold?.();
     const existing = cardElement(card.id);
     if (existing) {
       const drawn = drawCard(existing, card);
@@ -79,11 +84,13 @@ export function createCardsPlace({
   }
 
   // A snapshot's cards and notices, each above the first turn after it; a
-  // turn's own notice where it showed live (placeTurnNotice).
-  function placeSnapshotCards(entries) {
+  // turn's own notice where it showed live (placeTurnNotice). +end+: what
+  // closes the history below them (a failed turn's prompt), for those with
+  // no turn after them.
+  function placeSnapshotCards(entries, { before: end = null } = {}) {
     const users = turnPromptBubbles(historyEl);
     for (const entry of entries) {
-      const before = cardPlace(users, entry);
+      const before = cardPlace(users, entry) || end;
       if (isCard(entry)) upsertCard(entry, { before });
       else if (entry.type === "question") placeResolvedQuestion(entry, before);
       else if (entry.type === "guardrail_warning") bubbles.showGuardrailWarning(entry.message, entry.label || "guardrails", { before });
@@ -162,7 +169,18 @@ export function createCardsPlace({
     }, 150);
   }
 
-  // A card's action button (a click anywhere in the turn roots).
+  // Its command line's card is back in play: the worker refused the action.
+  function actionFailed(line) {
+    for (const button of findInTurnRoots(".plugin-card .card-action")) {
+      if (button.dataset.command === line) {
+        button.closest(".plugin-card").querySelectorAll(".card-action").forEach((b) => { b.disabled = false; });
+      }
+    }
+  }
+
+  // A card's action button (a click anywhere in the turn roots). A proposal
+  // card's buttons stay off until its folded card replaces them or the
+  // action fails (actionFailed): a second tap has nothing to do.
   function onCardAction(e) {
     const button = e.target.closest(".plugin-card .card-action");
     const id = selected();
@@ -170,7 +188,9 @@ export function createCardsPlace({
     const card = button.closest(".plugin-card");
     const err = card.querySelector(".card-error");
     err.classList.add("hidden");
-    button.disabled = true;
+    const held = HELD_UNTIL_ANSWERED.test(button.dataset.command);
+    const off = held ? [...card.querySelectorAll(".card-action")] : [button];
+    off.forEach((b) => { b.disabled = true; });
     api.sendCommand(id, button.dataset.command, { clientId, card: true })
       .then(() => {
         // The command woke the worker: follow its stream if none is open
@@ -180,9 +200,10 @@ export function createCardsPlace({
       .catch((error) => {
         err.textContent = error.message;
         err.classList.remove("hidden");
+        off.forEach((b) => { b.disabled = false; });
       })
-      .finally(() => { button.disabled = false; });
+      .finally(() => { if (!held) button.disabled = false; });
   }
 
-  return { cardElement, upsertCard, placeSnapshotCards, refreshCardBodies, onCardAction };
+  return { cardElement, upsertCard, placeSnapshotCards, refreshCardBodies, onCardAction, actionFailed };
 }

data/lib/samagotchi/web/public/commands.js

@@ -163,6 +163,8 @@ export function continueLine(choice, reason = "") {
 const QUEUED_TEXT = "queued: runs after this turn";
 const APPLY_TEXT = "Apply (restarts the cache)";
 
+const OBJECTIVES_LINE = /^\/objectives\b/;
+
 export function commandView(event, myId) {
   const own = isOwn(event.client_id, myId);
   const waiting = event.waits === "turn_end";
@@ -181,7 +183,8 @@ export function commandView(event, myId) {
     commandId: event.command_id || null,
     confirm: typeof event.confirm?.line === "string" ? event.confirm.line : null,
     // A card's action (Nudge…): no bubble unless it says something back.
-    hidden: event.card === true && !event.output && event.status !== "error",
+    // A tap's /objectives edit: the strip and the entry are its answer.
+    hidden: event.card === true && event.status !== "error" && (!event.output || OBJECTIVES_LINE.test(event.line || "")),
   };
 }
 

data/lib/samagotchi/web/public/details_motion.js

@@ -56,7 +56,8 @@ export function installDetailsMotion({ root, selector, motion = canAnimate }) {
     const summary = e.target.closest?.("summary");
     const details = summary?.parentElement;
     if (!details || !details.matches?.(selector) || summary.parentElement !== details) return;
-    if (e.target.closest("a, button, input, label") !== null && e.target !== summary) return;
+    // A live part of the summary (a steps block's footprint opens its own view).
+    if (e.target.closest("a, button, input, label, .ws-foot") !== null && e.target !== summary) return;
     if (!motion(details)) return;
     e.preventDefault();
     if (busy.has(details)) return;