samagotchi 0.10.1 → 0.11.0

data/lib/samagotchi/terminal_ui.rb

@@ -84,8 +84,8 @@ module Samagotchi
       @scratch        = scratch
       @prompt         = prompt
       @default_model_name = ModelProfile.required_model_name(nil)
-      aliased_model_name = model_name.to_s.strip.empty? ? nil : ConfigFile.resolve_model_alias(model_name)
-      flag_model_name = aliased_model_name.to_s.strip.empty? ? nil : ModelProfile.required_model_name(aliased_model_name)
+      # As typed: the Engine applies an alias where it resolves the model.
+      flag_model_name = model_name.to_s.strip.empty? ? nil : ModelProfile.required_model_name(model_name)
       @effective_model_name = flag_model_name || @default_model_name
       @host_registry  = host_registry || Samagotchi::HostRegistry.new
       # An injected client (specs) stands in for every host's client.
@@ -106,6 +106,7 @@ module Samagotchi
           @effective_model_name = flag_model_name
         else
           @effective_model_name = @resume_session.model_name.to_s.strip.empty? ? @default_model_name : @resume_session.model_name
+          @resumed_model_typed = @resume_session.model_typed
         end
         # Re-resolve client after resume may change effective model
         @client = @host_registry.resolve(@effective_model_name).client
@@ -115,7 +116,7 @@ module Samagotchi
       ModelProfile.check_host!(@effective_model_name, hosts: @host_registry.entries)
       # Only a caller's profile goes in; otherwise the Engine resolves one
       # for the effective model and hands it to the kernel.
-      @kernel         = KernelLoop.new(client: @client, profile: profile, no_interrupt: no_interrupt, reminder_store: Samagotchi::ReminderStore.new)
+      @kernel         = KernelLoop.new(client: @client, profile: profile, reminder_store: Samagotchi::ReminderStore.new)
       @no_default_input = no_default_input
       @non_interactive = non_interactive
       # --memory and --mute, with a resumed session's own lists first: a
@@ -180,7 +181,7 @@ module Samagotchi
                                       registry: @engine.command_registry)
       # Runtime --model flag or resumed session: switch the Engine (client,
       # kernel profile) without persisting the default.
-      @engine.switch_model!(@effective_model_name) if @effective_model_name != @default_model_name
+      @engine.switch_model!(@effective_model_name, typed: @resumed_model_typed) if @effective_model_name != @default_model_name
       # Render an idle session-recap via the cursor-safe background writer; the
       # detector itself is Engine-owned (see Engine#recap) and opt-in.
       @recap_handle = @engine.subscribe(observer: ->(event) { @between_turns.take_recap(event) })
@@ -217,14 +218,14 @@ module Samagotchi
       # nothing and return (no transient session, no banner).
       return if @non_interactive && @prompt.nil?
 
-      session = @resume_session || Session.new_session(
+      session = @resume_session || @engine.store_model!(Session.new_session(
         mode: "assist",
         model_name: @effective_model_name,
         working_directory: Dir.pwd,
         preloaded_memory_names: @requested_memories,
         muted_memory_names: @muted_memory_names,
         scratch: @scratch
-      )
+      ))
       claim_session!(session.id) unless @owner_lock
       # Saved at once, so a process killed before its first turn leaves a
       # file the sweep knows to delete.
@@ -691,7 +692,7 @@ module Samagotchi
     end
 
     def save_session(session)
-      session.model_name = @effective_model_name
+      @engine.store_model!(session)
       session.save
     end
 
@@ -760,7 +761,7 @@ module Samagotchi
       canceled = result.respond_to?(:canceled?) && result.canceled?
       if result && !canceled
         session.messages = result.conversation if result.respond_to?(:conversation) && result.conversation.is_a?(Array)
-        session.model_name = @effective_model_name
+        @engine.store_model!(session)
         session.save
       end
       # The synthetic turn is activity: the next reminder waits a full

data/lib/samagotchi/tool_response.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # A tool batch and the conversation entries its results become, for both
+  # loops. The calls run through ToolRunner between the dispatch events;
+  # what the model gets back is per format: the native loop answers a batch
+  # with ONE tool_response (#joined: the full outputs), the chat loop each
+  # call with its own, paired by tool_call_id (#single: the capped output,
+  # D-P2-6).
+  module ToolResponse
+    SEPARATOR = "\n\n---\n\n"
+    # Saved with a result for the web's reload (a plugin tool's params line
+    # and label, an edit/write's diff); the prompt never reads them.
+    SAVED_KEYS = %i[tool_params tool_labels tool_diffs].freeze
+
+    module_function
+
+    # Runs +calls+ in order (ToolRunner#run each), yielding each run and its
+    # index as it finishes. +emit+ takes the dispatch events, the runner's
+    # own go to +on_stream_event+.
+    # @return [Array<Hash>] the runs
+    def run_batch(runner, calls, iteration:, emit:, on_stream_event:, cap:)
+      emit.call({ type: :tool_dispatch_started, iteration: iteration, call_count: calls.length })
+      runs = calls.each_with_index.map do |call, index|
+        run = runner.run(call, iteration: iteration, call_index: index + 1, call_count: calls.length,
+                               on_stream_event: on_stream_event, max_tool_output_chars: cap)
+        yield run, index if block_given?
+        run
+      end
+      emit.call({ type: :tool_dispatch_completed, iteration: iteration, call_count: calls.length })
+      runs
+    end
+
+    # The runs' activity, for the turn's tool list (none for a call whose
+    # dispatcher raised).
+    def activities(runs)
+      runs.filter_map { |run| run[:activity] }
+    end
+
+    # The native loop's entry for a batch: the outputs joined, every image
+    # in call order with how many each call returned (the web's reload puts
+    # each on its own tool row), and the saved-only fields one per call.
+    def joined(runs)
+      images = runs.flat_map { |run| Array(run[:images]) }
+      entry = { role: "tool_response", content: runs.map { |run| run[:output] }.join(SEPARATOR) }
+      unless images.empty?
+        entry[:images] = images
+        entry[:image_counts] = runs.map { |run| Array(run[:images]).size }
+      end
+      saved = { tool_params: runs.map { |run| run[:shown_params] }, tool_labels: runs.map { |run| run[:shown_label] },
+                tool_diffs: runs.map { |run| run[:diff] } }
+      saved.each { |key, values| entry[key] = values if values.any? }
+      entry
+    end
+
+    # The chat loop's entry for one call: its capped output, paired with the
+    # call by +tool_call_id+.
+    def single(run, tool_call_id:)
+      entry = { role: "tool_response", content: run[:capped_output], tool_call_id: tool_call_id }
+      entry[:images] = run[:images] if run[:images]&.any?
+      entry[:tool_params] = run[:shown_params] if run[:shown_params]
+      entry[:tool_labels] = run[:shown_label] if run[:shown_label]
+      entry[:tool_diffs] = run[:diff] if run[:diff]
+      entry
+    end
+  end
+end

data/lib/samagotchi/tool_runner.rb

@@ -80,7 +80,12 @@ module Samagotchi
         capped = output[0, max_tool_output_chars]
       end
 
-      fire(:after_tool_call, { type: :after_tool_call, iteration: iteration, tool: call[:name], output: capped })
+      # The call's outcome as its activity line has it (worked out from the
+      # full output: ok, error, blocked, stopped); a dispatcher that raised
+      # left none, an error.
+      status = result[:activity].is_a?(Hash) ? result[:activity][:status] : nil
+      fire(:after_tool_call, { type: :after_tool_call, iteration: iteration, tool: call[:name], output: capped,
+                               status: status || "error" })
       completed = { type: :tool_call_completed, iteration: iteration, call_count: call_count, call_index: call_index,
                     tool: call[:name], output: capped, output_truncated: truncated, activity: result[:activity] }
       completed[:images] = images if images&.any?

data/lib/samagotchi/tools/delegate.rb

@@ -117,12 +117,13 @@ module Samagotchi
       end
       private_class_method :follow_up
 
-      # --model as the REPL reads it: an alias resolved, a host prefix kept.
-      # No existence check: an unknown model fails the child's first turn.
+      # The model as typed (spawn_session stores its resolved ref), else the
+      # parent's. No existence check: an unknown model fails the child's
+      # first turn.
       def self.child_model(model, parent)
         return parent.model_name if model.to_s.strip.empty?
 
-        ModelProfile.required_model_name(ConfigFile.resolve_model_alias(model.to_s.strip))
+        ModelProfile.required_model_name(model.to_s.strip)
       end
       private_class_method :child_model
 

data/lib/samagotchi/tools/memory.rb

@@ -22,7 +22,8 @@ module Samagotchi
 
       SEPARATOR = "\n\n---\n\n"
 
-      def self.call(entry_name, scope: nil, model_key: nil)
+      # @param fallback_model_key [String, nil] read when +model_key+ has no overlay
+      def self.call(entry_name, scope: nil, model_key: nil, fallback_model_key: nil)
         entry_name = entry_name.to_s.strip
         scope = normalize_scope(scope)
 
@@ -60,11 +61,12 @@ module Samagotchi
             if File.exist?(path)
               body = File.read(path)
               # Append model-specific overlay if key is provided and overlay exists.
-              if model_key
-                overlay_path = ModelOverlay.overlay_path_for(name, model_key, resolved_scope)
-                if overlay_path && File.exist?(overlay_path)
-                  body += SEPARATOR + "Model-specific guidance (#{model_key}):\n" + File.read(overlay_path)
-                end
+              [model_key, fallback_model_key].compact.each do |key|
+                overlay_path = ModelOverlay.overlay_path_for(name, key, resolved_scope)
+                next unless overlay_path && File.exist?(overlay_path)
+
+                body += SEPARATOR + "Model-specific guidance (#{key}):\n" + File.read(overlay_path)
+                break
               end
               results << body
               found = true

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -18,6 +18,7 @@ require_relative "../steer"
 require_relative "../host_registry"
 require_relative "../model_profile"
 require_relative "../project_scope"
+require_relative "../prompt_history"
 require_relative "../version"
 require_relative "../config"
 require_relative "../output_formatter"
@@ -127,6 +128,7 @@ module Samagotchi
         ["POST", %r{\A/api/sessions\z}, :handle_create],
         ["GET", %r{\A/api/info\z}, :handle_info],
         ["GET", %r{\A/api/models\z}, :handle_models],
+        ["GET", %r{\A/api/history\z}, :handle_history],
         ["GET", %r{\A/api/events\z}, :handle_events],
         ["GET", %r{\A/api/sessions/([^/]+)/stream\z}, :handle_stream],
         ["GET", %r{\A/api/sessions/([^/]+)/output\z}, :handle_output],
@@ -381,6 +383,25 @@ module Samagotchi
       # a bounded time for a fresh listing and answers with what it has, a
       # host that failed or the wait running out noted in +warning+, never a
       # failure: the default alone is enough for the page.
+      # GET /api/history: the prompt history the TUI's ↑ walks, which the
+      # composer's ↑/↓ share (PromptHistory), oldest first.
+      def handle_history(_req)
+        json_response(200, { entries: PromptHistory.entries })
+      end
+
+      # A line the page sent, once the worker took it, into the shared prompt
+      # history; "history": false (an image-only send's placeholder text)
+      # keeps it out. A failed write never fails the send. There's no scratch
+      # check: a live scratch session is the REPL's (OwnedByTUI, 409 before
+      # any delivery), and one whose REPL died is left as an edge case.
+      def record_history(body, line)
+        return if body["history"] == false
+
+        PromptHistory.append(line.to_s)
+      rescue StandardError => e
+        Log.warn(:web, "history_write_failed", error: e.class.name, msg: e.message)
+      end
+
       def handle_models(_req)
         default = begin
           ModelProfile.required_model_name
@@ -500,6 +521,7 @@ module Samagotchi
         port = await_bridge_port(session.id)
         # The projection holds it before the page hears back (no tick wait).
         @hub&.touch(session.id)
+        record_history(body, prompt) if !idle && PromptHistory.shell_line?(prompt.to_s.strip)
         json_response(201, session_to_json(session).merge(bridge_port: port))
       end
 
@@ -660,7 +682,9 @@ module Samagotchi
         request = ->(client) { client.post_command(line: line, client_id: body["client_id"], card: body["card"] == true) }
         relay(id, live_bridge_client(id), request, what: "the command was not run", cant: "run commands") do |reply|
           case reply.status
-          when 202 then json_response(202, reply.json || { status: "accepted" })
+          when 202
+            record_history(body, line) if PromptHistory.shell_line?(line)
+            json_response(202, reply.json || { status: "accepted" })
           when 400 then error_response(400, reply.json&.dig("error") || "unknown_command", reply_detail(reply, "not a session command"))
           end
         end
@@ -747,7 +771,9 @@ module Samagotchi
         result = SessionManager.deliver_turn(id, prompt: prompt.to_s, client_id: client_id, images: images, state_dir: @state_dir,
                                              manager: @manager, bridge: -> { live_bridge_client(id) })
         case result[:status]
-        when :accepted then json_response(202, result[:ack])
+        when :accepted
+          record_history(body, prompt)
+          json_response(202, result[:ack])
         when :refused then json_response(result[:code], result[:ack])
         when :timeout then error_response(504, "worker_timeout", result[:ack]["detail"])
         else error_response(500, "enqueue_failed", "could not write turn input")

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

@@ -14,6 +14,7 @@ import {
   createIdleSession,
   uploadImage,
   listModels,
+  fetchHistory,
 } from "./data.js";
 import { MODEL_KEY } from "./model_pick.js";
 import { emptySessionState } from "./session_state.js";
@@ -32,6 +33,7 @@ import { createQuestionCards } from "./question_cards.js";
 import { cardClass, cardInnerHtml, cardPlace, isCard, splitSnapshotCards, turnNoticePlace } from "./card.js";
 import { gripFloor, promptHeight } from "./composer_size.js";
 import { createCommandList } from "./command_list.js";
+import { createPromptHistory } from "./prompt_history.js";
 import { ALL_SESSIONS_HASH, sessionHash, sessionIdFromHash } from "./route.js";
 import { allScopeHref, cardFolder, projectScopeHref, scopeDir } from "./scope.js";
 import { shouldFollowScroll, keepFollowing } from "./scroll.js";
@@ -473,7 +475,7 @@ function setPlaceholder(long, short) {
 }
 
 // The key hint under the composer (shown while it has focus).
-const SEND_HINT = "Enter to send · Shift+Enter for a newline";
+const SEND_HINT = "Enter to send · Shift+Enter for a newline · ↑ history";
 
 // While a turn runs, Send still sends: the prompt merges into the turn at
 // its next step (steering). Cancel is its own button then.
@@ -1698,6 +1700,7 @@ async function handleCreate() {
     select(s.id);
     promptEl.value = "";
     fitPrompt();
+    refreshHistory();
   } catch (e) {
     alert(e.message);
   } finally {
@@ -1710,6 +1713,8 @@ async function handleSendTurn() {
   if (current.owner === "tui") return;
   const prompt = turnText(promptEl.value, chips);
   if (!prompt) return;
+  // An image-only send's text is its placeholders: not for ↑.
+  const typed = promptEl.value.trim() !== "";
   if (!chips.length && isCommandLine(prompt)) return handleSendCommand(prompt);
   if (!selected) {
     actionBtn.disabled = true;
@@ -1742,8 +1747,9 @@ async function handleSendTurn() {
     for (const chip of sending) {
       if (!chip.ref) chip.ref = await uploadImage(selected, chip.file, chip.name);
     }
-    const ack = await sendTurn(selected, prompt, { clientId, images: turnRefs(sending) });
+    const ack = await sendTurn(selected, prompt, { clientId, images: turnRefs(sending), history: typed });
     if (ack?.enqueued_id) sentIds.add(ack.enqueued_id);
+    refreshHistory();
     // A turn that failed fast was restored before this ack: its prompt
     // (and images) go back into the composer.
     const restored = restoreOnAck(ack?.enqueued_id, earlyRestores, { myId: clientId, sentIds });
@@ -1795,6 +1801,7 @@ async function handleSendCommand(line) {
     await sendCommand(selected, line, { clientId });
     promptEl.value = "";
     fitPrompt();
+    refreshHistory();
     // The command woke the worker: follow its stream if none is open.
     if (!streamControl?.live) startStream(selected, selectSeq ?? 0);
   } catch (e) {
@@ -2043,8 +2050,28 @@ const commandList = createCommandList({
   afterPick: () => fitPrompt(),
 });
 
+// ↑/↓: the prompt history shared with the TUI (prompt_history.js), from a
+// copy fetched on focus and after each send (keydown can't wait for one).
+const promptHistory = createPromptHistory();
+function refreshHistory() {
+  fetchHistory().then((entries) => promptHistory.setEntries(entries), () => {});
+}
+promptEl.addEventListener("focus", refreshHistory);
+function historyKey(e) {
+  if (e.isComposing || e.shiftKey || e.altKey || e.ctrlKey || e.metaKey) return false;
+  const step = e.key === "ArrowUp" ? promptHistory.up : e.key === "ArrowDown" ? promptHistory.down : null;
+  const recalled = step?.({ value: promptEl.value, start: promptEl.selectionStart, end: promptEl.selectionEnd });
+  if (!recalled) return false;
+  e.preventDefault();
+  promptEl.value = recalled.value;
+  promptEl.setSelectionRange(recalled.caret, recalled.caret);
+  fitPrompt();
+  return true;
+}
+
 promptEl.addEventListener("keydown", (e) => {
   if (commandList.handleKey(e)) return;
+  if (historyKey(e)) return;
   if (e.key === "Enter" && !e.shiftKey) {
     e.preventDefault();
     if (!selected) handleCreate();

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

@@ -45,6 +45,11 @@ export function listModels(opts = {}) {
   return api("/api/models", opts);
 }
 
+// The prompt history the composer's ↑/↓ walk (the TUI's too), oldest first.
+export function fetchHistory(opts = {}) {
+  return api("/api/history", opts).then((j) => (Array.isArray(j.entries) ? j.entries : []));
+}
+
 // Upload one image (the raw file as the body); answers its ref.
 export function uploadImage(id, file, name, opts = {}) {
   return api(`/api/sessions/${id}/images?name=${encodeURIComponent(name || file?.name || "image")}`, {
@@ -66,9 +71,12 @@ export function getSession(id, { tail, parts, cards, ...opts } = {}) {
 
 // opts.clientId: this tab's id, so the events tell its prompts from others'.
 // opts.images: refs ({file, name}) to images uploaded into the session.
-export function sendTurn(id, prompt, { clientId, images, ...opts } = {}) {
+// history: false keeps the prompt out of the shared prompt history (an
+// image-only send, whose text is only its [image: …] placeholders).
+export function sendTurn(id, prompt, { clientId, images, history = true, ...opts } = {}) {
   const body = clientId ? { prompt, client_id: clientId } : { prompt };
   if (images?.length) body.images = images;
+  if (history === false) body.history = false;
   return api(`/api/sessions/${id}/turn`, {
     method: "POST",
     body: JSON.stringify(body),

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

@@ -0,0 +1,63 @@
+// ↑/↓ in the composer: the prompt history the TUI's ↑ walks (GET
+// /api/history, oldest first), shared by every chi prompt. Pure: the page
+// hands in the composer's value and selection, and sets what comes back.
+//
+// ↑ recalls only with the caret on the first line and nothing selected,
+// ↓ moves forward only while browsing and from the last line; otherwise
+// the keys are the browser's (null). ↑ puts the caret at the start, so ↑
+// again keeps walking back; ↓ at the end. Past the newest entry ↓ brings
+// back the draft there was when browsing started. Browsing ends whenever
+// the value isn't the one the history last set: typing, a send clearing
+// it, a refill, a quote — every path that sets the value, unhooked.
+// An entry equal to the one just shown is skipped.
+
+const onFirstLine = ({ value, start }) => !value.slice(0, start).includes("\n");
+const onLastLine = ({ value, end }) => !value.slice(end).includes("\n");
+
+export function createPromptHistory() {
+  let entries = [];
+  let index = -1; // the entry shown; -1 = not browsing
+  let draft = "";
+  let lastSet = null;
+
+  function browsing(value) {
+    if (index >= 0 && value !== lastSet) index = -1;
+    return index >= 0;
+  }
+
+  function show(i, caretAtEnd) {
+    index = i;
+    lastSet = entries[i];
+    return { value: lastSet, caret: caretAtEnd ? lastSet.length : 0 };
+  }
+
+  return {
+    // The list as fetched; a place in it survives while its entry does.
+    setEntries(list) {
+      entries = Array.isArray(list) ? list.map(String) : [];
+      if (index >= 0) index = entries.lastIndexOf(lastSet);
+    },
+
+    up(state) {
+      const was = browsing(state.value);
+      if (state.start !== state.end || !onFirstLine(state)) return null;
+      const shown = was ? lastSet : state.value;
+      let i = was ? index - 1 : entries.length - 1;
+      while (i >= 0 && entries[i] === shown) i--;
+      if (i < 0) return null;
+      if (!was) draft = state.value;
+      return show(i, false);
+    },
+
+    down(state) {
+      if (!browsing(state.value)) return null;
+      if (state.start !== state.end || !onLastLine(state)) return null;
+      let i = index + 1;
+      while (i < entries.length && entries[i] === lastSet) i++;
+      if (i < entries.length) return show(i, true);
+      index = -1;
+      lastSet = null;
+      return { value: draft, caret: draft.length };
+    },
+  };
+}

data/lib/samagotchi/worker.rb

@@ -45,7 +45,7 @@ module Samagotchi
     COMMAND_OUTPUT_LIMIT = 4096
     BUSY_OUTPUT = "busy: wait for the turn to end"
     DEFAULT_MAX_ITERATIONS = 100
-    NO_INTERRUPT_MAX_ITERATIONS = 1000
+    NO_INTERRUPT_MAX_ITERATIONS = 1000 # as Engine::NO_INTERRUPT_MAX_ITERATIONS
 
     # Wakes the worker loop. Whoever queues work writes it first and wakes
     # after, and #wait drains every wake before the loop looks for work: a
@@ -216,6 +216,7 @@ module Samagotchi
       engine = nil
       engine = Samagotchi::Engine.new(
         model_name: @session.model_name,
+        model_typed: @session.model_typed,
         # The session's --memory and --mute lists: the same prompt on every
         # (re)spawn.
         memories: @session.preloaded_memory_names,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -277,6 +277,7 @@ files:
 - lib/samagotchi/memory_paths.rb
 - lib/samagotchi/model_overlay.rb
 - lib/samagotchi/model_profile.rb
+- lib/samagotchi/model_ref.rb
 - lib/samagotchi/muted_memories.rb
 - lib/samagotchi/note_command.rb
 - lib/samagotchi/output_formatter.rb
@@ -293,6 +294,7 @@ files:
 - lib/samagotchi/plugin_tasks.rb
 - lib/samagotchi/project_scope.rb
 - lib/samagotchi/prompt.rb
+- lib/samagotchi/prompt_history.rb
 - lib/samagotchi/prompt_literal_guard.rb
 - lib/samagotchi/question_desk.rb
 - lib/samagotchi/recap_setup.rb
@@ -329,6 +331,7 @@ files:
 - lib/samagotchi/terminal_ui/plain_surface.rb
 - lib/samagotchi/terminal_ui/question_prompt.rb
 - lib/samagotchi/terminal_ui/question_slot.rb
+- lib/samagotchi/terminal_ui/reline_history_hook.rb
 - lib/samagotchi/terminal_ui/reline_seam.rb
 - lib/samagotchi/terminal_ui/repl_input.rb
 - lib/samagotchi/terminal_ui/screen.rb
@@ -343,6 +346,7 @@ files:
 - lib/samagotchi/tool_activity.rb
 - lib/samagotchi/tool_call_parser.rb
 - lib/samagotchi/tool_declarations.rb
+- lib/samagotchi/tool_response.rb
 - lib/samagotchi/tool_runner.rb
 - lib/samagotchi/tools/args.rb
 - lib/samagotchi/tools/ask_user_question.rb
@@ -408,6 +412,7 @@ files:
 - lib/samagotchi/web/public/model_picker.js
 - lib/samagotchi/web/public/notifications.js
 - lib/samagotchi/web/public/notify.js
+- lib/samagotchi/web/public/prompt_history.js
 - lib/samagotchi/web/public/question_card.js
 - lib/samagotchi/web/public/question_cards.js
 - lib/samagotchi/web/public/route.js