samagotchi 0.159.0 → 0.161.0

data/lib/samagotchi/tools/send_note.rb

@@ -26,13 +26,19 @@ module Samagotchi
         Session.load(id, state_dir: peers.state_dir)
         return "Error: #{id[0, 8]} is this session; send_note is for other sessions" if id == peers.session_id
 
+        # A link continued into this one: the note would come back here.
+        head = SessionInbox::Head.resolve(:note, id, state_dir: peers.state_dir)
+        return "Error: #{id[0, 8]} was continued into this session; send_note is for other sessions" if head.id == peers.session_id
+
         result = NoteDelivery.deliver(id, text: content, source: "session", from_session: peers.session_id,
-                                          from_cwd: peers.cwd, state_dir: peers.state_dir)
-        return "Error: session #{id[0, 8]}: #{result.refusal}" if result.scratch
-        return "Error: session #{id[0, 8]} is #{OwnerLock::TUI_BUSY}, which can't take notes" unless result.delivered?
+                                          from_cwd: peers.cwd, state_dir: peers.state_dir, resolved: head)
+        target = result.id[0, 8]
+        return "Error: session #{target}: #{result.refusal}" if result.scratch
+        return "Error: session #{target} is #{OwnerLock::TUI_BUSY}, which can't take notes" unless result.delivered?
 
         where = result.status == :queued ? "its worker adds it before its next turn" : "it has no worker now, so it waits for its next start"
-        "Queued a note for session #{id[0, 8]}: #{where}. It does not start a turn there."
+        via = result.continued? ? " (#{id[0, 8]} was continued: #{target} is its chain's newest link)" : ""
+        "Queued a note for session #{target}#{via}: #{where}. It does not start a turn there."
       rescue Session::NotFound => e
         "Error: #{e.message} (list_sessions shows them)"
       rescue ArgumentError => e # AmbiguousId, SessionInbox::NoteRejected, a file that won't load

data/lib/samagotchi/turn_stages/context_judge.rb

@@ -89,7 +89,8 @@ module Samagotchi
       def pass(session, texts, phase:, state_dir:, recorder:)
         return if session.id.nil? || session.scratch
 
-        rows = ContextCandidates.with_status(session.id, project_root: session.project_root, state_dir: state_dir)
+        rows = ContextCandidates.with_status(session.id, project_root: session.project_root,
+                                                         project_id: session.project_id, state_dir: state_dir)
         return if rows.empty?
 
         log = ContextCandidatesLog.log_for(state_dir)
@@ -134,6 +135,7 @@ module Samagotchi
       def choice(session, log, settings, state_dir)
         session_id = session.id
         project_root = session.project_root
+        project_id = session.project_id
         show = lambda do |**card|
           current = @current_session.call
           next nil unless current.nil? || current.id == session_id
@@ -146,6 +148,7 @@ module Samagotchi
         end
         lambda do |job, fields|
           ContextCandidateChoice.after_judged(job: job, fields: fields, settings: settings, project_root: project_root,
+                                              project_id: project_id,
                                               state_dir: state_dir, log: log, show_card: show)
         end
       end
@@ -156,12 +159,9 @@ module Samagotchi
       def parent_attached(session, state_dir)
         return nil unless session.delegate? && session.parent_id
 
-        parent_root = if Session.exist?(session.parent_id, state_dir: state_dir)
-                        Session.load(session.parent_id, state_dir: state_dir).project_root
-                      else
-                        session.project_root
-                      end
-        ContextSources.attached(session.parent_id, project_root: parent_root, state_dir: state_dir)
+        parent = Session.exist?(session.parent_id, state_dir: state_dir) ? Session.load(session.parent_id, state_dir: state_dir) : session
+        ContextSources.attached(session.parent_id, project_root: parent.project_root, project_id: parent.project_id,
+                                                   state_dir: state_dir)
                       .map { |attached| attached.source.title || attached.name }
       rescue StandardError => e
         Log.warn(:context, "context_parent_attached_failed", error: e.class.name, msg: e.message.to_s[0, 200])

data/lib/samagotchi/turn_state.rb

@@ -15,6 +15,8 @@ module Samagotchi
   # so any lock may be held around a call into it, and it is never held
   # around anything else.
   class TurnState
+    ENQUEUED_ID_HISTORY = 256
+
     # @param clock [#call] monotonic seconds
     def initialize(clock:)
       @clock = clock
@@ -32,6 +34,80 @@ module Samagotchi
       @last_context = nil
       @steers = []
       @carried_steers = []
+      @enqueued_ids = {}
+      @enqueued_order = []
+    end
+
+    # Reserve an id for a Bridge-enqueued input. False means this id was
+    # already accepted in this worker.
+    def reserve_enqueued_id(id)
+      id = id.to_s
+      return false if id.empty?
+
+      @lock.synchronize do
+        next false if @enqueued_ids.key?(id)
+
+        remember_enqueued_id(id, :queued)
+        true
+      end
+    end
+
+    # Claim an input file. A Bridge reservation permits its first file claim;
+    # a duplicate file with the same id is refused. Unreserved files are
+    # accepted once too.
+    def claim_enqueued_id(id)
+      id = id.to_s
+      return true if id.empty?
+
+      @lock.synchronize do
+        case @enqueued_ids[id]
+        when :queued
+          @enqueued_ids[id] = :running
+          true
+        when nil
+          remember_enqueued_id(id, :running)
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def finish_enqueued_id(id)
+      id = id.to_s
+      return if id.empty?
+
+      @lock.synchronize do
+        @enqueued_ids[id] = :ended if @enqueued_ids[id] == :running
+        prune_enqueued_ids
+      end
+    end
+
+    def forget_enqueued_id(id)
+      id = id.to_s
+      return if id.empty?
+
+      @lock.synchronize do
+        next unless @enqueued_ids[id] == :queued
+
+        @enqueued_ids.delete(id)
+        @enqueued_order.delete(id)
+      end
+    end
+
+    def drop_enqueued_id(id)
+      id = id.to_s
+      return if id.empty?
+
+      @lock.synchronize do
+        @enqueued_ids[id] = :ended if @enqueued_ids[id] == :queued
+        prune_enqueued_ids
+      end
+    end
+
+    def enqueued_id?(id)
+      id = id.to_s
+      !id.empty? && @lock.synchronize { @enqueued_ids.key?(id) }
     end
 
     # ── Activity clock ──────────────────────────────────────────────────
@@ -179,11 +255,22 @@ module Samagotchi
       @lock.synchronize { !@input_waiting_warned.tap { @input_waiting_warned = true } }
     end
 
-    # Cancel the running turn, if any (outside the lock).
-    # @return [Boolean] whether a cancellation was triggered
-    def cancel!(reason)
-      ctrl = controller
+    # Cancel the running turn, if any (the controller is taken, and the turn
+    # id compared, under the lock; it is cancelled outside it).
+    # @param turn_id [String, nil] the turn the caller means: another turn
+    #   running (a Stop that arrived as its turn ended) is left alone; nil
+    #   cancels whichever runs
+    # @return [Boolean, Symbol] whether a cancellation was triggered, or
+    #   :turn_mismatch when +turn_id+ is not the running turn's
+    def cancel!(reason, turn_id: nil)
+      ctrl = @lock.synchronize do
+        next nil unless @controller
+        next :mismatch if turn_id && @context&.id != turn_id
+
+        @controller
+      end
       return false unless ctrl
+      return :turn_mismatch if ctrl == :mismatch
 
       ctrl.cancel!(reason)
     end
@@ -238,5 +325,22 @@ module Samagotchi
     def take_steers
       @lock.synchronize { @steers.tap { @steers = [] } }
     end
+
+    private
+
+    def remember_enqueued_id(id, status)
+      @enqueued_ids[id] = status
+      @enqueued_order << id
+      prune_enqueued_ids
+    end
+
+    def prune_enqueued_ids
+      while @enqueued_ids.size > ENQUEUED_ID_HISTORY
+        index = @enqueued_order.index { |id| @enqueued_ids[id] == :ended }
+        break unless index
+
+        @enqueued_ids.delete(@enqueued_order.delete_at(index))
+      end
+    end
   end
 end

data/lib/samagotchi/update_command.rb

@@ -310,7 +310,9 @@ module Samagotchi
       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?
+      if read_by_someone? && (error = system.clear_merge_notes(earlier, files: result.merged)).is_a?(String)
+        row.status = [row.status, error].compact.join("; ")
+      end
       row
     end
 
@@ -356,14 +358,17 @@ module Samagotchi
       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), *notes, replaced(update.replaced), *update.kept_own, update.note].compact
+        notes = [adds(update.added_files), adds(update.adds), *notes, replaced(update.replaced), *update.kept_own, update.note].compact
         done(row, :update, notes.empty? ? nil : notes.join("; "))
       when :would_merge, :merged, :up_to_date then same_version(row, [*notes, update.note, update.manifest].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
+      if read_by_someone? && update.status != :failed
+        error = MemoryBundle::Provenance.new(name: update.name).clear_merge_notes(earlier, files: row.merged)
+        row.status = [row.status, error].compact.join("; ") if error.is_a?(String)
+      end
       row
     end
 
@@ -522,7 +527,7 @@ module Samagotchi
       row
     end
 
-    # A profile's new members: "+ btw".
+    # New memory files or profile members: "+ file".
     def adds(members)
       members.nil? || members.empty? ? nil : "+ #{members.join(", ")}"
     end

data/lib/samagotchi/verify_fresh.rb

@@ -6,6 +6,7 @@ require "time"
 require_relative "atomic_file"
 require_relative "log"
 require_relative "session"
+require_relative "session_inbox"
 require_relative "session_metrics"
 require_relative "session_row"
 require_relative "worker_link"
@@ -86,8 +87,10 @@ module Samagotchi
         refuse_busy!(parent.id, of, author, state_dir)
 
         child = spawn.call(prompt: prompt_for(anchor.quote), working_directory: parent.working_directory,
-                           model_name: parent.model_name, memories: [Session::DELEGATE_MEMORY],
-                           parent_id: parent.id, delegate: true, verify_fresh: origin, state_dir: state_dir)
+                           model_name: parent.model_name,
+                           setup: SessionSetup.new(preloaded_memory_names: [Session::DELEGATE_MEMORY]),
+                           parent_id: parent.id, delegate: true, verify_fresh: origin, state_dir: state_dir,
+                           client_id: ClientId.delegate(parent.id))
         append_ledger(dir, { "child_id" => child.id, "of" => of, "author" => author, "at" => Time.now.utc.iso8601(3) })
         child
       end
@@ -160,28 +163,43 @@ module Samagotchi
 
     # The child's new verdicts (+records+, Engine's verdict records) into
     # its parent's INBOX, marked fresh: true with the child's id and the
-    # verdict they check again (of). Best effort.
+    # verdict they check again (of). Best effort. A session inbox delivery
+    # (SessionInbox.deliver :fresh_verdict): pinned to the parent the child
+    # names (its original verdict's card is there, a continued one's too),
+    # never a worker started for it; a parent that is gone gets nothing.
     # @param child [Session] a Verify fresh child
     # @return [Integer] how many were written
     def forward(child, records, state_dir: Session.default_state_dir)
       fresh = child&.verify_fresh
-      return 0 unless fresh&.of && child.parent_id && Session.exist?(child.parent_id, state_dir: state_dir)
+      return 0 unless fresh&.of && child.parent_id
 
-      dir = File.join(Session.session_dir(child.parent_id, state_dir: state_dir), INBOX)
+      written = 0
+      SessionInbox.deliver(:fresh_verdict, child.parent_id, state_dir: state_dir, wake: false) do |at|
+        written = write_verdicts(Session.session_dir(at, state_dir: state_dir), child, fresh.of, records)
+        false
+      end
+      written
+    rescue StandardError => e
+      Log.warn(:worker, "fresh_forward_failed", parent: child&.parent_id.to_s[0, 8], error: e.class.name, msg: e.message)
+      0
+    end
+
+    # +records+ into +session_dir+'s INBOX, one file per check turn.
+    # @return [Integer] how many were written
+    def write_verdicts(session_dir, child, of, records)
+      dir = File.join(session_dir, INBOX)
       FileUtils.mkdir_p(dir)
       Array(records).count do |record|
         check = field(record, :check_turn_id).to_s
         next false unless Session.valid_id?(check)
 
         out = record.to_h { |key, value| [key.to_s, value.is_a?(Hash) ? value.transform_keys(&:to_s) : value] }
-        out.merge!("fresh" => true, "of" => fresh.of, "child_id" => child.id)
+        out.merge!("fresh" => true, "of" => of, "child_id" => child.id)
         AtomicFile.write(File.join(dir, "#{check}.json"), JSON.generate(out))
         true
       end
-    rescue StandardError => e
-      Log.warn(:worker, "fresh_forward_failed", parent: child&.parent_id.to_s[0, 8], error: e.class.name, msg: e.message)
-      0
     end
+    private_class_method :write_verdicts
 
     # The verdicts waiting in +session_dir+'s INBOX: [[record, file]],
     # oldest first.

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -1030,7 +1030,7 @@ module Samagotchi
 
         # One normal form for the decision, the mkdir and the realpath (a `..` after a symlink would differ).
         dir = File.expand_path(dir)
-        outcome = ProjectInit.call(dir, home: home)
+        outcome = ProjectInit.call(dir, home: home, state_dir: default_state_dir)
         return error_response(422, outcome.reason.to_s, outcome.message) if outcome.kind == :refused
 
         if outcome.kind == :git
@@ -1455,7 +1455,8 @@ module Samagotchi
         body = { session_id: id, sources: rows, can_add_url: ContextProviders.any? }
         # The candidates too, for chi context ls (no UI shows them yet).
         if full
-          body[:candidates] = ContextCandidates.with_status(id, project_root: session.project_root, state_dir: default_state_dir)
+          body[:candidates] = ContextCandidates.with_status(id, project_root: session.project_root, project_id: session.project_id,
+                                                            state_dir: default_state_dir)
                                                .map { |candidate, status| candidate.to_h.merge("name" => candidate.name, "status" => status) }
         end
         json_response(200, body)
@@ -1573,8 +1574,8 @@ module Samagotchi
       end
 
       def attached_context(session, shadowed: false)
-        ContextSources.attached(session.id, project_root: session.project_root, state_dir: default_state_dir,
-                                            shadowed: shadowed)
+        ContextSources.attached(session.id, project_root: session.project_root, project_id: session.project_id,
+                                            state_dir: default_state_dir, shadowed: shadowed)
       end
 
       # @return [ContextSources::Attached, nil]
@@ -1895,7 +1896,7 @@ module Samagotchi
       def session_to_json(s, status: s.status, owner: nil)
         SessionSummary.build(s, status: status, owner: owner,
                                 session_dir: @session_class.session_dir(s.id, state_dir: default_state_dir),
-                                registry: host_registry)
+                                registry: host_registry, compat_version: @hub&.installed || VERSION)
       end
 
       def parse_json(str)

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

@@ -2,7 +2,7 @@ import {
   listSessions,
   getSession,
   sendTurn,
-  cancelTurn,
+  stopTurn,
   stopSession,
   sessionHolds,
   stopSessionHolds,
@@ -1675,12 +1675,7 @@ function queueRefused(altKey) {
 // The stage's Stop turn (its button stays disabled until this settles).
 async function handleCancel() {
   if (!store.selected) return;
-  try {
-    await cancelTurn(store.selected);
-  } catch (e) {
-    // The turn ended meanwhile: nothing left to cancel.
-    if (e.code !== "not_running") alert(e.message);
-  }
+  await stopTurn(store.selected, liveTurn.timing.turnId, { resync: () => resync(), onError: (e) => alert(e.message) });
 }
 
 // The chi logo: back to the empty start, where the composer makes a new

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

@@ -138,9 +138,9 @@ export function linksPruned(links, byId) {
 }
 
 // The session page's neighbours of +id+: {prev, next}, each {id, session}
-// or null, and +pruned+: the session's own `continues` names a link the list
-// does not hold (a schedule pruned it, or it was deleted). +continues+: the
-// open session's own `continues`, when the list may not have caught up with it.
+// or null, and +pruned+: the listed session's `continues` names a link the list
+// does not hold (a schedule pruned it, or it was deleted). +continues+: the open
+// session's own `continues`, when the list may not have caught up with it.
 // A previous link the list doesn't hold is null: its link would open a
 // not-found page.
 export function chainNeighbours(list, id, { continues = null } = {}) {
@@ -150,7 +150,7 @@ export function chainNeighbours(list, id, { continues = null } = {}) {
   const prev = prevSession ? { id: prevId, session: prevSession } : null;
   const nextSession = nextsOf(list).get(id) || null;
   const next = nextSession ? { id: nextSession.id, session: nextSession } : null;
-  return { prev, next, pruned: !!prevId && !prevSession };
+  return { prev, next, pruned: !!self && !!prevId && !prevSession };
 }
 
 const pad = (n) => String(n).padStart(2, "0");

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

@@ -181,11 +181,15 @@ export function renderText(text, opts = {}) {
   });
 }
 
+// +turnId+: the turn the Stop is for, when the page knows it; a Stop that
+// arrives as that turn ends is refused (409 turn_mismatch), not applied to
+// the next turn.
 export function cancelTurn(id, opts = {}) {
+  const { turnId = null, ...rest } = opts;
   return api(`/api/sessions/${id}/cancel`, {
     method: "POST",
-    body: JSON.stringify({ reason: "user" }),
-    ...opts,
+    body: JSON.stringify(turnId ? { reason: "user", turn_id: turnId } : { reason: "user" }),
+    ...rest,
   });
 }
 
@@ -216,6 +220,18 @@ export function markSystemOneWrong(id, judgmentId, opts = {}) {
   });
 }
 
+// The stage's Stop: cancelTurn, quiet when the turn ended meanwhile. When
+// another turn began (turn_mismatch) the page's turn id was stale, so it
+// resyncs and the next Stop names the current turn; other errors go to onError.
+export async function stopTurn(id, turnId, { resync, onError, ...opts } = {}) {
+  try {
+    await cancelTurn(id, { turnId, ...opts });
+  } catch (e) {
+    if (e.code === "turn_mismatch") resync?.();
+    else if (e.code !== "not_running") onError?.(e);
+  }
+}
+
 export function stopSession(id, opts = {}) {
   return api(`/api/sessions/${id}/stop`, { method: "POST", body: JSON.stringify({}), ...opts });
 }

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

@@ -19,7 +19,7 @@ export const SPEED_NONE = "– tok/s";
 // @param versions {served, installed}: the chi serving the page, the newest
 export function workerBadgeFor(id, state, versions) {
   if (!id || state.owner !== "worker") return null;
-  return workerBadge({ workerVersion: state.workerVersion, features: state.workerFeatures,
+  return workerBadge({ workerVersion: state.workerVersion, compatibility: state.workerCompat, features: state.workerFeatures,
                        installed: versions.installed, served: versions.served, sessionId: id });
 }
 

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

@@ -88,6 +88,7 @@ export const FIELDS = {
     redraws: ["featureGates", "infoBar"],
     writers: "followSelectedSession",
   },
+  workerCompat: { card: (sess) => sess.worker_compat || null, redraws: ["infoBar"], writers: "followSelectedSession" },
   bridgeUp: {
     card: (sess) => sess.bridge_up === true,
     redraws: ["featureGates", "infoBar"],
@@ -114,10 +115,10 @@ export const FIELDS = {
 // The fields a hub card brings for the open session (followSelectedSession):
 // its owner and worker. Never its status: that goes through setStatus, so
 // "the hub's status only while not streaming" can't be bypassed.
-const CARD_FIELDS = ["owner", "workerVersion", "workerFeatures", "bridgeUp"];
+const CARD_FIELDS = ["owner", "workerVersion", "workerFeatures", "workerCompat", "bridgeUp"];
 
 // @param sess a hub card (the open session's)
-// @return {owner, workerVersion, workerFeatures, bridgeUp}
+// @return {owner, workerVersion, workerFeatures, workerCompat, bridgeUp}
 export function fieldsFromCard(sess) {
   return Object.fromEntries(CARD_FIELDS.map((key) => [key, FIELDS[key].card(sess)]));
 }

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

@@ -55,6 +55,7 @@ export function emptySessionState() {
     // worker_version / worker_features): the info bar's stale-worker badge.
     workerVersion: null,
     workerFeatures: [],
+    workerCompat: null,
     bridgeUp: false,
     // The LLM context strategy, apply rule and budget the next turn runs
     // under, each with its source (the info bar's ⚙ chip), or null.
@@ -99,6 +100,7 @@ export function sessionStateFrom(data) {
     // not at the session's next hub event (followSelectedSession).
     workerVersion: s.worker_version || null,
     workerFeatures: Array.isArray(s.worker_features) ? s.worker_features : [],
+    workerCompat: s.worker_compat || null,
     bridgeUp: s.bridge_up === true,
     timing: normalizeTiming(data.timing),
   };

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

@@ -117,9 +117,9 @@ export function updateFrameToast(data, { wasOpen = false, snapshot = false } = {
 // else null. A worker with the "restart" feature offers Restart; an older
 // one can only be stopped (any message then starts it on the newest chi).
 // @return {{text, title, newest, restart: boolean} | null}
-export function workerBadge({ workerVersion, features, installed, served, sessionId = "" } = {}) {
+export function workerBadge({ workerVersion, compatibility, features, installed, served, sessionId = "" } = {}) {
   const newest = known(installed) ? installed : served;
-  if (!newerVersion(newest, workerVersion)) return null;
+  if (!known(newest) || !known(workerVersion) || compatibility !== "restart_suggested") return null;
   if (Array.isArray(features) && features.includes("restart")) {
     return {
       text: `chi ${workerVersion}`,

data/lib/samagotchi/web/session_access_routes.rb

@@ -101,7 +101,7 @@ module Samagotchi
           brief: true,
           session: { id: session.id, status: session.status, title: session.title,
                      display_title: session.display_title, project_root: session.project_root,
-                     working_directory: session.working_directory, model_name: session.model_name,
+                     project_id: session.project_id, working_directory: session.working_directory, model_name: session.model_name,
                      model_typed: session.model_typed, parent_answers: session.parent_answers,
                      owner: owner&.kind },
           pending_question: session.pending_question&.to_file
@@ -432,8 +432,10 @@ module Samagotchi
       # POST /api/sessions/:id/notes {text, source}: a context note for the
       # session (NoteDelivery, as chi note; source: where it came from,
       # "cli" by default, never "broadcast"). 200 {status: "queued" (a
-      # worker adds it) or "waits" (the next start does), session_id,
-      # queued}; 409 owned_by_tui (status refused: a one-turn chi run has it); 400
+      # worker adds it) or "waits" (the next start does), session_id, id
+      # (the session that has it: session_id, or its chain's newest link
+      # when session_id was continued), queued}; 409 owned_by_tui (status refused: a one-turn chi run has it, or a
+      # scratch session: scratch; id as above); 400
       # note_rejected (empty, or over 16 KiB).
       def handle_notes(req, id)
         body = body_hash(req) or return error_response(400, "invalid_json", "invalid JSON body")
@@ -446,12 +448,13 @@ module Samagotchi
         session_access.show(id)
         result = session_access.note(id, text: text, source: source.strip)
         if result.status == :refused
-          error = result.scratch ? SessionManager::ScratchSession.new(id) : SessionManager::OwnedByTUI.new(id)
-          return refusal_response(409, "owned_by_tui", error, session_id: id, status: "refused", queued: 0,
-                                                             scratch: result.scratch || nil)
+          # Named by the link that refused it (its chain's newest, for a continued one).
+          error = result.scratch ? SessionManager::ScratchSession.new(result.id) : SessionManager::OwnedByTUI.new(result.id)
+          return refusal_response(409, "owned_by_tui", error, session_id: id, id: result.id, status: "refused",
+                                                             queued: 0, scratch: result.scratch || nil)
         end
 
-        json_response(200, { status: result.status.to_s, session_id: id, queued: result.queued })
+        json_response(200, { status: result.status.to_s, session_id: id, id: result.id, queued: result.queued })
       rescue SessionInbox::NoteRejected => e
         error_response(400, "note_rejected", e.message)
       end
@@ -459,7 +462,8 @@ module Samagotchi
       # POST /api/sessions/:id/context/:name/push {text, summary, wake,
       # hint}: new text for the session's --push source (chi context push;
       # the fields as a source's JSON output gives them, checked the same
-      # way). 200 {status: "pushed", name, before, revision, changed}; 404
+      # way). 200 {status: "pushed", name, before, revision, changed, wake:
+      # what a push that asked for a wake did, absent when it asked none}; 404
       # context_missing (no such source); 409 not_push (a command source); 410
       # context_continued (the session was continued, as next_id: never 409,
       # which an older Remote reads as not_push, nor "continued", which it
@@ -481,7 +485,7 @@ module Samagotchi
           json_response(410, { error: "context_continued", next_id: pushed.next_id,
                                detail: SessionAccess::ContextPush.continued_message(name, id, pushed.next_id) })
         else json_response(200, { status: "pushed", name: name, before: pushed.before, revision: pushed.revision,
-                                  changed: pushed.before != pushed.revision })
+                                  changed: pushed.before != pushed.revision }.merge(pushed.wake ? { wake: pushed.wake } : {}))
         end
       rescue ContextSources::Invalid
         error_response(404, "context_missing", "no source #{name[0, 40]}")
@@ -492,8 +496,8 @@ module Samagotchi
       # @raise [ArgumentError] no such session
       def context_target(id)
         session = session_access.show(id)
-        ContextCommand::Target.new(session_id: id, project_root: session.project_root, cwd: session.working_directory,
-                                   label: id[0, 8])
+        ContextCommand::Target.new(session_id: id, project_root: session.project_root, project_id: session.project_id,
+                                   cwd: session.working_directory, label: id[0, 8])
       end
     end
   end

data/lib/samagotchi/web/session_control.rb

@@ -301,13 +301,19 @@ module Samagotchi
         reason = (parsed["reason"] if parsed.is_a?(Hash)).to_s.strip
         reason = "user" if reason.empty?
 
-        request = ->(client) { client.cancel(reason: reason) }
+        turn_id = (parsed["turn_id"] if parsed.is_a?(Hash)).to_s.strip
+        request = ->(client) { turn_id.empty? ? client.cancel(reason: reason) : client.cancel(reason: reason, turn_id: turn_id) }
         relay(id, bridge_client(id), request, what: "the turn was not cancelled", cant: "cancel turns") do |reply|
           case reply.status
           when 202
             json_response(202, { status: "cancel_requested", session_id: id, reason: reply.json&.dig("reason"), via: "bridge" })
-          # No active turn to cancel.
-          when 409 then json_response(409, { error: "not_running", detail: "no active turn to cancel", session_id: id })
+          when 409
+            if reply.json&.dig("error") == "turn_mismatch"
+              json_response(409, { error: "turn_mismatch", detail: "the running turn is not the one named", session_id: id })
+            else
+              # No active turn to cancel.
+              json_response(409, { error: "not_running", detail: "no active turn to cancel", session_id: id })
+            end
           end
         end
       end

data/lib/samagotchi/web/session_create.rb

@@ -120,7 +120,9 @@ module Samagotchi
                       ReviewStart.start(subjects: review.subjects, dir: dir || start_dir, model: folder[:model_name],
                                         setup: setup, state_dir: @state_dir)
                     else
-                      @manager.spawn_session(prompt: idle ? nil : prompt.to_s, state_dir: @state_dir, **folder)
+                      @manager.spawn_session(prompt: idle ? nil : prompt.to_s,
+                                             client_id: body["client_id"] || ClientId::WEB_CREATE,
+                                             state_dir: @state_dir, **folder)
                     end
         rescue ModelProfile::MissingModel => e
           # No model configured, or one qualified with an unknown host.
@@ -169,7 +171,8 @@ module Samagotchi
         return refused if refused
 
         session, error = continue_from(given, prompt: idle ? nil : prompt.to_s, preview: preview.empty? ? nil : preview,
-                                              model: model.empty? ? nil : model)
+                                              model: model.empty? ? nil : model,
+                                              client_id: body["client_id"] || ClientId::WEB_CREATE)
         return error if error
 
         port = await_worker_link(session.id).then { |link| link.live? ? link.port : nil }
@@ -331,8 +334,9 @@ module Samagotchi
       # SessionContinue.run, its refusals as responses: [session,
       # nil] or [nil, the response]. Only its own errors: what fails after
       # the new link started is not a refusal of it.
-      def continue_from(given, prompt:, preview:, model:)
-        [SessionContinue.run(given, prompt: prompt, preview: preview, model: model, state_dir: @state_dir), nil]
+      def continue_from(given, prompt:, preview:, model:, client_id:)
+        [SessionContinue.run(given, prompt: prompt, preview: preview, model: model, state_dir: @state_dir,
+                                    client_id: client_id), nil]
       rescue SessionContinue::Refused => e
         extra = e.reason == :continued ? { next_id: e.ids.first } : {}
         [nil, refusal_response(409, e.reason.to_s, e, session_id: e.session_id, reason: e.reason.to_s, ids: e.ids, **extra)]