samagotchi 0.130.0 → 0.131.0

data/lib/samagotchi/web/app.rb

@@ -55,6 +55,7 @@ require_relative "../review_start"
 require_relative "../parent_answers_command"
 require_relative "../guardrails/parent_policy"
 require_relative "markdown_renderer"
+require_relative "token"
 require_relative "capabilities"
 require_relative "editor"
 require_relative "../message_parts"
@@ -431,6 +432,10 @@ module Samagotchi
       end
 
       TOKEN_COOKIE = "chi_token"
+      # The owner's cookie holds the token, but on the LAN a loopback
+      # peer's holds Token.loopback_cookie (#owner_cookie_value): a cookie
+      # for 127.0.0.1 goes to every server on any of its ports (a dev
+      # server that logs headers), and that value works nowhere else.
       # 400 days, the longest a browser keeps a cookie (Chrome's cap). No
       # Secure: the LAN page is plain http. Lax, not Strict: a token link
       # opened from another site (a web messenger) makes its 303 chain
@@ -473,10 +478,10 @@ module Samagotchi
         principal = principal_for(req)
         return [nil, refused_token(req)] if principal.nil?
 
-        # The cookie gets the token that was presented: the owner's, or the
-        # participant's grant's.
+        # The cookie gets the participant's grant's token, or the owner's
+        # cookie value (the loopback one on the LAN's 127.0.0.1).
         if token_trade?(req)
-          token = req.env[GRANT_TOKEN_ENV] || current_token
+          token = req.env[GRANT_TOKEN_ENV] || owner_cookie_value(req)
           return [nil, token_redirect(req, token)] unless fragment_trade?(req)
           return [nil, form_trade_redirect(req, token)] if form_post?(req)
 
@@ -492,7 +497,9 @@ module Samagotchi
       # one, looked up only when no owner token was given), wherever the
       # request comes from, this machine's loopback too; with neither, the
       # owner only on a chi web that asks no token (loopback only: no LAN
-      # mode, no web.public_url), else nil. An ended or unknown grant's
+      # mode, no web.public_url), else nil. The owner's cookie on the LAN's
+      # loopback is the loopback value (#loopback_cookie: it stands for the
+      # token in +given+). An ended or unknown grant's
       # token is nil anywhere: it never falls back to the owner.
       # @return [Principal, nil]
       # With web.public_url (ProxyGate) every request needs a token, and a
@@ -512,12 +519,39 @@ module Samagotchi
       # through the proxy (curl, chi's own callers) presents the Bearer
       # header only: no cookie, and no trade that would set one. A cookie for
       # 127.0.0.1 goes to every server on any of its ports. A LAN peer
-      # (web.host lan) keeps the LAN's token link and cookie.
+      # (web.host lan) keeps the LAN's token link and cookie; a loopback
+      # peer of a LAN chi web reads its cookie through #loopback_cookie.
       def presented_tokens(req)
         return [traded_token(req)] if token_trade?(req)
         return [bearer_token(req)] if direct_public?(req)
 
-        [bearer_token(req), req.cookies[token_cookie_name(req)]]
+        cookie = req.cookies[token_cookie_name(req)]
+        [bearer_token(req), loopback_cookie_peer?(req) ? loopback_cookie(cookie) : cookie]
+      end
+
+      # A loopback peer of a LAN chi web, whose owner cookie holds the
+      # loopback value. With web.public_url, #direct_public? takes the
+      # Bearer only. A request with a proxy's trace (one the user forwards
+      # to loopback by hand) is the LAN's: a leaked loopback value must not
+      # work from off this machine through it.
+      def loopback_cookie_peer?(req)
+        !@lan.nil? && @public_url.nil? && LOOPBACK_PEERS.include?(req.get_header("REMOTE_ADDR").to_s) &&
+          !proxy_trace?(req.env)
+      end
+
+      # What a trade sets as the owner's cookie.
+      def owner_cookie_value(req)
+        loopback_cookie_peer?(req) ? Token.loopback_cookie(current_token) : current_token
+      end
+
+      # A loopback peer's cookie: the loopback value stands for the owner's
+      # token, a grant's chp_ token is itself, and anything else, the token
+      # itself included (a 0.130.0 cookie, #refused_token clears it), is
+      # nothing.
+      def loopback_cookie(value)
+        return current_token if token_match?(value, Token.loopback_cookie(current_token))
+
+        Grants.token?(value) ? value : nil
       end
 
       def direct_public?(req)
@@ -622,10 +656,15 @@ module Samagotchi
       # The 401 for a request #principal_for refused: an ended grant's, else
       # unauthorized. On a peer the gate doesn't ask, a grant's cookie that
       # no longer works is cleared too, so the browser it was left in (the
-      # owner's, who opened a participant link) is the owner's again.
+      # owner's, who opened a participant link) is the owner's again. A
+      # LAN chi web's loopback peer whose cookie is the token itself (set
+      # before the loopback value) has it cleared, so it stops riding to
+      # the other local ports.
       def refused_token(req)
         response = grant_bound_response(req) || grant_ended_response(req) || unauthorized(req)
-        return response if token_required?(req) || !Grants.token?(req.cookies[token_cookie_name(req)])
+        cookie = req.cookies[token_cookie_name(req)]
+        stale = loopback_cookie_peer?(req) && token_match?(cookie, current_token)
+        return response unless stale || (!token_required?(req) && Grants.token?(cookie))
 
         status, headers, body = response
         [status, headers.merge("Set-Cookie" => cleared_token_cookie(req)), body]

data/lib/samagotchi/web/participant_review.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "participant_view"
+require_relative "token"
 require_relative "participant_stream_filter"
 require_relative "participant_exposure"
 require_relative "../session_metrics"
@@ -39,10 +40,16 @@ module Samagotchi
 
       # Who reads: the participant (their author), or the owner through the
       # participant view (nobody's own). The session's folder places tool
-      # paths; the owner's token is never shown.
+      # paths; the owner's token is never shown, nor (LAN) its loopback
+      # cookie value.
       def participant_viewer(req, session)
         author = principal(req).owner? ? nil : principal(req).grant.author
-        ParticipantView::Viewer.new(author: author, cwd: session.working_directory, secrets: [(@lan || @public_url) && current_token].compact)
+        ParticipantView::Viewer.new(author: author, cwd: session.working_directory, secrets: owner_secrets)
+      end
+
+      def owner_secrets
+        token = (@lan || @public_url) && current_token
+        [token, @lan && Token.loopback_cookie(token)].compact
       end
 
       # GET /api/sessions/:id/review: the participant page's data, always

data/lib/samagotchi/web/participant_view.rb

@@ -211,7 +211,8 @@ module Samagotchi
       # @return [Array<Hash>] {role: "user", content, turn_id, author,
       #   author_name, mine, automatic, images, at} and {role: "assistant",
       #   content, tools: [{tool, path}], at}; no notes, steers, automatic
-      #   input or empty-answer markers. html is added by the caller, from
+      #   input or empty-answer markers, but a wake turn's start as an
+      #   automatic turn (#wake_start). html is added by the caller, from
       #   this (redacted) content.
       def messages(shown, viewer, automatic: [])
         Array(shown).filter_map do |message|
@@ -220,6 +221,7 @@ module Samagotchi
           out = case field(message, :role).to_s
                 when "user" then user_message(message, viewer, automatic)
                 when "assistant" then assistant_message(message, viewer)
+                when "note" then wake_start(message)
                 end
           out && Redact.deep(out, viewer)
         end
@@ -228,15 +230,15 @@ module Samagotchi
       # A user message a participant sees: a turn's prompt (it has the
       # turn's id) or a person's line merged into a turn. Every other user
       # message is dropped: the owner's `!` line and its output, a
-      # delegate's report (a wake turn's input), the notes chi adds (a
-      # Continue the owner declined). Any message from a source that isn't a
-      # person's is dropped whatever it is.
+      # delegate's report (a wake turn's input: only its turn's start is
+      # kept, #wake_start), the notes chi adds (a Continue the owner
+      # declined). Any other message from a source that isn't a person's is
+      # dropped whatever it is.
       def user_message(message, viewer, automatic = [])
         source = field(message, :source).to_s
-        return nil unless PERSON_SOURCES.include?(source)
-
         turn_id = field(message, :turn_id)
         merged = field(message, :merged)
+        return (turn_id && !merged ? wake_start(message) : nil) unless PERSON_SOURCES.include?(source)
         return nil unless turn_id || merged
 
         out = { "role" => "user", **time_field(message) }
@@ -254,6 +256,20 @@ module Samagotchi
         out
       end
 
+      # A wake turn's start (its prompt a delegate's report or a context
+      # note, MessageDisplay's turn_start note): the turn's boundary only,
+      # as an automatic turn with no text, so its answer is never read as
+      # one more reply of the turn before (Verify, verdict cards, claim
+      # links group by these). Nothing of the report or the note. nil for
+      # a message that starts no turn.
+      def wake_start(message)
+        turn_id = field(message, :turn_id)
+        return nil if turn_id.to_s.empty?
+        return nil if field(message, :role).to_s == "note" && field(message, :turn_start) != true
+
+        { "role" => "user", **time_field(message), "content" => "", "automatic" => true, "turn_id" => turn_id.to_s }
+      end
+
       def assistant_message(message, viewer)
         parts = field(message, :parts)
         tools = parts.is_a?(Hash) ? Array(field(parts, :tools)) : []

data/lib/samagotchi/web/proxy_gate.rb

@@ -74,6 +74,12 @@ module Samagotchi
         return true if @public_url.host?(env["HTTP_HOST"])
         return true if @public_url.identity_env && env.key?(@public_url.identity_env)
 
+        proxy_trace?(env)
+      end
+
+      # Whether a request carries a proxy's trace (ProxyTrace: X-Forwarded-*,
+      # Forwarded, X-Real-IP, a known identity header).
+      def proxy_trace?(env)
         names = env[RAW_NAMES_ENV] || env.keys.filter_map { |key| ProxyTrace.env_name(key) }
         names.any? { |name| ProxyTrace.header?(name) }
       end

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

@@ -33,6 +33,9 @@ import { actionEnabled, actionTitle, sameActions, selectionFields, splitInline }
 // @param onQuote (text) runs with the quote (and a preset's note) to append
 //   to the composer; the selection is cleared and the bar hidden first
 // @param disabledPreset (preset) → a reason to disable it, else null
+// @param offeredPreset (preset, source, range) → whether the selection
+//   offers it (default: every preset); one not offered is hidden, not
+//   disabled (Verify outside a turn's final answer: verify_target.js)
 // @param actions () => the open session's annotation actions
 //   (annotate_actions.js annotationActions), read on every selection
 // @param running () => whether a turn runs (a send pill may wait for it)
@@ -58,6 +61,7 @@ import { actionEnabled, actionTitle, sameActions, selectionFields, splitInline }
 //   next frame (call it on scroll)
 export function createAnnotateBar({
   presets, canAnnotate, roots, isLive, onQuote, onPreset = () => {}, disabledPreset = () => null,
+  offeredPreset = () => true,
   actions = () => [], running = () => false, onAction = () => {},
   dock = () => null, source: sourceOf = annotationSource, quote = quoteBlock, link = () => null, onLink = () => {},
   doc = globalThis.document, win = globalThis.window,
@@ -85,6 +89,7 @@ export function createAnnotateBar({
   const presetButtons = [...bar.children].slice(1, presets.length + 1);
   function markPresets() {
     presetButtons.forEach((btn, i) => {
+      btn.hidden = !!pendingSource && !offeredPreset(presets[i], pendingSource, pendingRange);
       const reason = disabledPreset(presets[i]);
       btn.disabled = !!reason;
       btn.title = reason || presetParts(presets[i]).text;
@@ -259,7 +264,7 @@ export function createAnnotateBar({
       return;
     }
     const preset = btn.dataset.index === undefined ? null : presets[Number(btn.dataset.index)];
-    if (btn.disabled || (preset && disabledPreset(preset))) return;
+    if (btn.disabled || btn.hidden || (preset && disabledPreset(preset))) return;
     const text = preset ? presetNote(pendingQuote, presetParts(preset).text) : pendingQuote;
     const fields = { ...pendingFields, source: pendingSource, range: pendingRange };
     win.getSelection()?.removeAllRanges();

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

@@ -65,6 +65,7 @@ import { authorBadge, nameUnnamedBadges } from "./participant_names.js";
 import { parsePresets } from "./annotate_presets.js";
 import { createAnnotateBar } from "./annotate_bar.js";
 import { VERIFY_PRESET, VERIFY_UNAVAILABLE, verifyWorkerUnavailable, withVerify } from "./verify_preset.js";
+import { OWNER_FINAL, verifyTurnOf } from "./verify_target.js";
 import { actionLine, annotationActions, composerWithAction } from "./annotate_actions.js";
 import { copyText, installCopy } from "./copy.js";
 import { createQuestionCards } from "./question_cards.js";
@@ -1351,6 +1352,8 @@ function placeVerdict(record) {
   placeVerdictWithFresh(historyEl, record, {
     who: badge ? badge.name : "You",
     author: record.by || null,
+    roots: CLAIM_ROOTS,
+    opts: claimOpts(),
     onMissingCheck: (missing) => {
       const hash = ownerCheckHash(allSessions, selected, missing.check_turn_id);
       if (hash) location.hash = hash;
@@ -1959,8 +1962,9 @@ const updateSheet = createUpdateSheet({
 function showToast(text, action = null, options = {}) { toasts.show(text, action, options); }
 
 // Annotate (annotate_bar.js): a selection in the conversation offers
-// "Annotate" and the presets (then the built-in Verify: verify_preset.js),
-// which append a quote to the composer, the session's plugins' pills
+// "Annotate" and the presets (then the built-in Verify: verify_preset.js,
+// only in an ended turn's final answer: verify_target.js), which append a
+// quote to the composer, the session's plugins' pills
 // (chi.annotation, annotate_actions.js), which fill the composer with their
 // command line and the quote, or send it at once, and Copy link in a turn
 // (claimLinkFor).
@@ -1978,6 +1982,7 @@ annotateBar = createAnnotateBar({
   presets: withVerify(parsePresets(document.body.dataset.annotatePresets)),
   disabledPreset: (preset) => preset === VERIFY_PRESET
     && verifyWorkerUnavailable(current.workerFeatures, current.bridgeUp) ? VERIFY_UNAVAILABLE : null,
+  offeredPreset: (preset, source, range) => preset !== VERIFY_PRESET || !!verifyAnchorFor({ source, range }),
   canAnnotate: () => !!selected && current.owner !== "tui",
   roots: turnRoots,
   isLive: (root) => liveTurn.running && turnDom.containsLive(root),
@@ -1997,10 +2002,14 @@ annotateBar = createAnnotateBar({
   dock: () => $("#dock"),
 });
 
+// Verify's claim: a selection in an ended turn's final answer (the only
+// text Engine#verified_anchor takes; verify_target.js), else null and no
+// Verify on the bar.
 function verifyAnchorFor({ source, range }) {
-  if (!source || !["answer", "step", "user"].includes(source.kind) || !historyEl.contains(source.root)) return null;
-  const turnId = turnIdOf(historyEl, source.root);
-  const quote = selectionClaim(source.root, range, claimOpts()).q;
+  if (source?.kind !== "answer" || !range) return null;
+  const running = liveTurn.running ? { turnId: liveTurn.timing.turnId || null } : null;
+  const turnId = verifyTurnOf(historyEl, source.root, OWNER_FINAL, { running });
+  const quote = turnId ? selectionClaim(source.root, range, claimOpts()).q : "";
   return turnId && quote ? { turn_id: turnId, quote } : null;
 }
 historyEl.addEventListener("scroll", annotateBar.schedule);

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

@@ -23,6 +23,7 @@ import { REPLACE_SESSION_TEXT, fragmentCode, tradeFragmentCode } from "./token_f
 import { createAnnotateBar } from "./annotate_bar.js";
 import { parsePresets } from "./annotate_presets.js";
 import { VERIFY_PRESET, VERIFY_UNAVAILABLE, withVerify } from "./verify_preset.js";
+import { PARTICIPANT_FINAL, verifyTurnOf } from "./verify_target.js";
 import { appendQuote } from "./annotations.js";
 import { messageAuthorData, participantQuote, participantSource } from "./participant_annotate.js";
 import { claimFromHash, selectionClaim, showClaim } from "./claim_link.js";
@@ -76,6 +77,8 @@ let drawnMessages = [];
 // A claim link's turn and quote (claim_link.js: #s=…&t=…&q=…), shown once
 // the thread is drawn; a later hash change shows another.
 let pendingClaim = claimFromHash(globalThis.location?.hash);
+// Where a claim's text can be on this page (a claim link, a verdict's card).
+const CLAIM_ROOTS = ".p-msg > .p-bubble";
 let claimNoteTimer = null;
 
 function el(tag, cls, text) {
@@ -259,7 +262,7 @@ function showPendingClaim() {
     return showClaimNote(`This link is for another session; this browser holds your link for ${title}.`);
   }
   setView("thread");
-  if (showClaim($("thread"), claim, { roots: ".p-msg > .p-bubble" })) return;
+  if (showClaim($("thread"), claim, { roots: CLAIM_ROOTS })) return;
   $("main").scrollTop = 0;
   showClaimNote("The linked turn isn't in this session.");
 }
@@ -330,6 +333,8 @@ function setView(view) {
   $("segThread").setAttribute("aria-selected", String(shown === "thread"));
 }
 
+const AUTOMATIC_TURN = "An automatic turn";
+
 function messageNode(message) {
   const user = message.role === "user";
   const node = el("div", `p-msg ${user ? "user" : "reply"}${message.mine ? " mine" : ""}`);
@@ -346,7 +351,10 @@ function messageNode(message) {
     if (message.merged) who.append(el("span", "p-tag", "added mid-turn"));
     if (isParticipantAuthor(message.author)) who.append(el("span", "p-tag", modeCopy(message.participant_mode).tag));
     node.append(who);
-    const text = message.content + (message.images ? `\n[${message.images} image${message.images > 1 ? "s" : ""}]` : "");
+    // An automatic turn (a task's, a wake turn's: a delegate report or a
+    // context note started it) opens its turn without its prompt.
+    const content = message.automatic && !message.content ? AUTOMATIC_TURN : message.content;
+    const text = content + (message.images ? `\n[${message.images} image${message.images > 1 ? "s" : ""}]` : "");
     node.append(el("div", "p-bubble", text));
     return node;
   }
@@ -423,6 +431,7 @@ function renderThread() {
     placeVerdictWithFresh(thread, record, {
       who,
       author,
+      roots: CLAIM_ROOTS,
       onMissingCheck: () => showClaimNote(CHECK_NOT_ON_PAGE),
     }, verifyFreshState());
   }
@@ -477,7 +486,7 @@ function currentTurnNodes() {
   const turn = data.current_turn;
   const nodes = [];
   if (turn.prompt !== undefined || turn.automatic) {
-    nodes.push(messageNode({ role: "user", content: turn.automatic ? "An automatic turn" : turn.prompt, author: turn.author,
+    nodes.push(messageNode({ role: "user", content: turn.automatic ? AUTOMATIC_TURN : turn.prompt, author: turn.author,
       author_name: turn.author_name, mine: turn.mine, automatic: turn.automatic, at: turn.at, turn_id: turn.turn_id }));
   }
   const reply = el("div", "p-msg reply live");
@@ -653,7 +662,8 @@ for (const button of $("viewSeg").querySelectorAll("button")) {
 
 // Annotate (annotate_bar.js, participant_annotate.js): a selection in the
 // Plan or the thread offers "Annotate" and the presets
-// (web.annotate_presets, then the built-in Verify: verify_preset.js), which
+// (web.annotate_presets, then the built-in Verify: verify_preset.js, only
+// in an ended turn's final reply: verify_target.js), which
 // append a quote to the comment box; nothing is sent. No plugin pills: a
 // review turn refuses `/` lines. Not in the owner's participant view, nor
 // while this participant can't comment.
@@ -661,6 +671,7 @@ const annotateBar = createAnnotateBar({
   presets: withVerify(parsePresets(body.annotatePresets)),
   disabledPreset: (preset) => preset === VERIFY_PRESET
     && data?.session?.verify_unavailable === true ? VERIFY_UNAVAILABLE : null,
+  offeredPreset: (preset, source, range) => preset !== VERIFY_PRESET || !!verifyAnchorFor({ source, range }),
   canAnnotate: () => !ownerView && !ended && !!data?.viewer?.can_comment,
   roots: () => [$("planDoc"), $("thread")],
   isLive: (root) => !!root.closest?.(".p-msg.live"),
@@ -671,9 +682,16 @@ const annotateBar = createAnnotateBar({
   dock: () => $("dock"),
 });
 
+// Verify's claim: a selection in an ended turn's final reply (the last
+// reply bubble after the turn's opening, as the owner's page and
+// placeVerdict count turns: verify_target.js), the only text
+// Engine#verified_anchor takes; else null and no Verify on the bar. Not an
+// earlier reply, a line merged mid-turn, a prompt, the running turn or the
+// Plan.
 function verifyAnchorFor({ source, range }) {
-  const message = source?.root?.closest?.(".p-msg");
-  const turnId = message?.dataset?.turnId;
+  if (source?.kind !== "reply" || !range) return null;
+  const running = data?.current_turn ? { turnId: data.current_turn.turn_id || null } : null;
+  const turnId = verifyTurnOf($("thread"), source.root, PARTICIPANT_FINAL, { running });
   if (!turnId) return null;
   const quote = selectionClaim(source.root, range).q;
   return quote ? { turn_id: turnId, quote } : null;

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

@@ -1,4 +1,4 @@
-import { ownerClaimHash } from "./claim_link.js";
+import { findClaim, ownerClaimHash } from "./claim_link.js";
 
 const TYPES = Object.freeze({
   confirmed: { icon: "✅", label: "confirmed" },
@@ -17,7 +17,14 @@ export function ownerCheckHash(sessions, currentSessionId, checkTurnId) {
   return session ? ownerClaimHash(session.id, { turnId: checkTurnId }) : null;
 }
 
-export function placeVerdict(root, record, { who = "Owner", author = null, onMissingCheck = null } = {}) {
+// A verdict's card on its source turn: after the bubble that holds the
+// quote (+roots+, the page's claim roots selector; +opts+, how it reads the
+// page's text, claim_link.js), the answer's first; a quote not found (a
+// bubble not drawn yet): at the turn's end. Cards on one bubble keep their
+// order; a card already on the page is returned as it is.
+export function placeVerdict(root, record, {
+  who = "Owner", author = null, onMissingCheck = null, roots = null, opts = {},
+} = {}) {
   const anchor = record?.anchor;
   const type = TYPES[record?.verdict];
   if (!root || !type || typeof anchor?.turn_id !== "string" || typeof anchor?.quote !== "string"
@@ -67,11 +74,48 @@ export function placeVerdict(root, record, { who = "Owner", author = null, onMis
   });
   card.append(heading, quote, reason, link);
 
-  const previous = cards.filter((candidate) => candidate.dataset.sourceTurnId === anchor.turn_id).at(-1);
-  (previous || source).after(card);
+  afterCards(quotedElement(source, anchor.quote, roots, opts) || turnEnd(source)).after(card);
   return card;
 }
 
+// The element at +source+'s level that holds the quote: of the turn's
+// roots after its prompt, the last match first (the answer the Engine
+// checked the quote against comes after the turn's steps).
+function quotedElement(source, quote, selector, opts) {
+  if (!selector || !source.parentElement) return null;
+  const level = source.parentElement;
+  const candidates = turnElements(source).flatMap((element) =>
+    [...(element.matches(selector) ? [element] : []), ...element.querySelectorAll(selector)]).reverse();
+  const hit = findClaim(candidates.map((candidate) => candidate.textContent), { q: quote }, opts);
+  if (!hit) return null;
+  let element = candidates[hit.at];
+  while (element && element.parentElement !== level) element = element.parentElement;
+  return element || null;
+}
+
+// +source+'s turn: its siblings after it up to the next turn's opening
+// (or a gap divider before it).
+function turnElements(source) {
+  const elements = [];
+  for (let next = source.nextElementSibling; next; next = next.nextElementSibling) {
+    if (next.matches("[data-turn-id]") || next.querySelector("[data-turn-id]")) break;
+    elements.push(next);
+  }
+  while (elements.at(-1)?.classList.contains("time-gap")) elements.pop();
+  return elements;
+}
+
+function turnEnd(source) {
+  return turnElements(source).at(-1) || source;
+}
+
+// +element+, or the last of the verdict cards right after it.
+function afterCards(element) {
+  let last = element;
+  while (last.nextElementSibling?.classList.contains("verify-verdict")) last = last.nextElementSibling;
+  return last;
+}
+
 export function nameVerdictCards(root, nameFor) {
   for (const card of root?.querySelectorAll?.(".verify-verdict[data-author]") || []) {
     const name = nameFor(card.dataset.author);

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

@@ -51,7 +51,8 @@ export function redrawFresh(root, fresh = {}) {
 
 // The card's Verify fresh part, drawn again from +fresh+: the fresh
 // verdicts, the running check, else the button (an unclear verdict, and a
-// viewer who could run a turn now).
+// viewer who could run a turn now; "Verify fresh again" after a fresh
+// verdict, each press another paid check).
 export function renderFresh(card, fresh = {}) {
   const doc = card.ownerDocument;
   const of = card.dataset.checkTurnId;
@@ -68,7 +69,10 @@ export function renderFresh(card, fresh = {}) {
     return link;
   };
 
-  for (const result of (fresh.verdicts || []).filter((r) => r?.fresh && r.of === of)) {
+  const results = (fresh.verdicts || []).filter((r) => r?.fresh && r.of === of);
+  // Once a fresh verdict is in, the button says a press runs another one.
+  const label = results.length ? "Verify fresh again" : "Verify fresh";
+  for (const result of results) {
     const line = doc.createElement("p");
     line.className = `verify-fresh-result ${ICONS[result.verdict] ? result.verdict : ""}`.trim();
     line.textContent = `fresh: ${ICONS[result.verdict] || ""} ${result.verdict} — ${result.reason || ""}`;
@@ -89,7 +93,7 @@ export function renderFresh(card, fresh = {}) {
     const button = doc.createElement("button");
     button.type = "button";
     button.className = "verify-fresh-btn";
-    button.textContent = "Verify fresh";
+    button.textContent = label;
     button.title = fresh.unavailableReason;
     button.disabled = true;
     const note = doc.createElement("p");
@@ -100,7 +104,7 @@ export function renderFresh(card, fresh = {}) {
     const button = doc.createElement("button");
     button.type = "button";
     button.className = "verify-fresh-btn";
-    button.textContent = "Verify fresh";
+    button.textContent = label;
     button.title = "A new agent checks this claim against the files, with none of this session's context";
     button.addEventListener("click", () => startFresh(card, button, fresh));
     part.append(button);

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

@@ -0,0 +1,73 @@
+// Where the Verify preset is offered (verify_preset.js), on both pages: only
+// on text in an ended turn's final answer, the one place the server takes a
+// claim from. Engine#verified_anchor records a Verify turn's card only when
+// its quote is in the last answer of the source turn (AnswerTail.answer?:
+// the turn's last assistant message with text, from its prompt up to the
+// next prompt, merged lines and steers inside); anything else (an earlier
+// reply, a step, a person's line, a reply still running) is refused with
+// `quote_missing` and the turn runs as a plain comment, no card. So the
+// page offers Verify where the server will accept it, and nowhere else.
+//
+// The turn is the page's own grouping (claim_link.js turnIdOf,
+// verdict_card.js turnElements): the last turn opening ([data-turn-id]) at
+// or before the selection, and its elements up to the next opening. Its
+// final answer is the last of them matching the page's answer selector.
+//
+// Pure DOM reads (Element, compareDocumentPosition), so it runs under
+// `node --test` with happy-dom. A module of its own: static JS is cached at
+// unversioned URLs, and a new export on an old module would blank the page.
+
+const PRECEDING = 2;
+
+// The owner's page: an answer bubble (not a delegate report's reply, which
+// a turn shows before its answer); a context note ends a turn's elements
+// (a wake turn starts with one, and its bubble carries no turn id).
+export const OWNER_FINAL = Object.freeze({ answers: ".bubble.output:not(.report-reply)", boundary: ".bubble.note" });
+// The participant page: a reply's bubble.
+export const PARTICIPANT_FINAL = Object.freeze({ answers: ".p-msg.reply > .p-bubble", boundary: null });
+
+// The turn opening +node+ is in (the last [data-turn-id] at or before it in
+// +container+) and whether it is the newest one: {anchor, last}, or null.
+function openingOf(container, node) {
+  const anchors = [...container.querySelectorAll("[data-turn-id]")];
+  let at = -1;
+  anchors.forEach((anchor, i) => {
+    if (anchor === node || anchor.contains(node) || (node.compareDocumentPosition(anchor) & PRECEDING)) at = i;
+  });
+  return at < 0 ? null : { anchor: anchors[at], last: at === anchors.length - 1 };
+}
+
+// The final answer of the turn whose opening is +anchor+: the last element
+// matching +answers+ among the opening's siblings after it, up to the next
+// opening or a +boundary+ element. null when it has none.
+function finalAnswer(container, anchor, { answers, boundary }) {
+  let top = anchor;
+  while (top && top.parentElement !== container) top = top.parentElement;
+  if (!top) return null;
+  let final = null;
+  for (let el = top.nextElementSibling; el; el = el.nextElementSibling) {
+    if (el.matches("[data-turn-id]") || el.querySelector("[data-turn-id]")) break;
+    if (boundary && el.matches(boundary)) break;
+    const inside = [...el.querySelectorAll(answers)];
+    if (inside.length) final = inside[inside.length - 1];
+    else if (el.matches(answers)) final = el;
+  }
+  return final;
+}
+
+// The turn id Verify anchors to for a selection in +root+ (the annotate
+// source's root) in +container+, or null where Verify isn't offered: not in
+// a turn, not in its final answer, or in the running turn. +rule+:
+// OWNER_FINAL or PARTICIPANT_FINAL. +running+: null when no turn runs, else
+// {turnId} (the running turn's id; null when unknown, then the newest turn
+// counts as the running one) — a running turn's answer isn't final yet.
+export function verifyTurnOf(container, root, rule, { running = null } = {}) {
+  if (!container || !root || !container.contains(root)) return null;
+  const opening = openingOf(container, root);
+  if (!opening) return null;
+  const turnId = opening.anchor.dataset.turnId || null;
+  if (!turnId) return null;
+  if (running && (opening.last || (running.turnId && running.turnId === turnId))) return null;
+  const final = finalAnswer(container, opening.anchor, rule);
+  return final && (final === root || final.contains(root)) ? turnId : null;
+}

data/lib/samagotchi/web/token.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "openssl"
 require "securerandom"
 require_relative "../atomic_file"
 
@@ -14,11 +15,15 @@ module Samagotchi
     # can read, $XDG_STATE_HOME/samagotchi/web-token (0600). It is made on
     # the first LAN start and kept, so a phone's bookmark survives
     # restarts; `chi web --new-token` replaces it. A loopback-only chi web
-    # never reads it.
+    # never reads it. The owner's cookie for this machine's 127.0.0.1
+    # holds #loopback_cookie, never the token: a server on any other local
+    # port is sent that cookie too.
     module Token
       FILE = "web-token"
       # 32 random bytes: 43 URL-safe characters.
       BYTES = 32
+      LOOPBACK_PREFIX = "chl_"
+      LOOPBACK_LABEL = "chi web loopback cookie v1"
 
       module_function
 
@@ -49,6 +54,20 @@ module Samagotchi
         SecureRandom.urlsafe_base64(BYTES)
       end
 
+      # The owner's 127.0.0.1 cookie on the LAN: an HMAC of a label keyed
+      # by +token+, so a leaked one gives nothing about the token, and
+      # rotating the token ends it. The gate takes it only as that cookie,
+      # from an unproxied loopback peer (App#loopback_cookie_peer?).
+      # @return [String, nil] "chl_" and 43 URL-safe characters; nil
+      #   without a token
+      def loopback_cookie(token)
+        return nil if token.nil? || token.empty?
+
+        # URL-safe base64 without padding (pack: base64 isn't a default gem).
+        digest = OpenSSL::HMAC.digest("SHA256", token, LOOPBACK_LABEL)
+        LOOPBACK_PREFIX + [digest].pack("m0").tr("+/", "-_").delete("=")
+      end
+
       # Written whole under a temporary name, then renamed over +path+: a
       # reader never sees half a token. The file is 0600 from the start,
       # its folder 0700 when this makes it.

data/lib/samagotchi/worker.rb

@@ -251,6 +251,13 @@ module Samagotchi
       ChildMove.clear_starting(@session_id, state_dir: @state_dir)
       ChildMove.adopt(@session_id, state_dir: @state_dir)
       @session = Session.load(@session_id, state_dir: @state_dir)
+      # A newer chi saved it: this worker keeps the fields it doesn't know
+      # but runs the session without them (docs/sessions.md).
+      if @session.newer_writer?
+        unknown = @session.extra_fields.keys.join(",")
+        Log.warn(:worker, "newer_writer", sid: @session_id, version: VERSION, written_by: @session.written_by,
+                                          unknown_fields: (unknown unless unknown.empty?))
+      end
       drop_dead_question
       # The running turn, on disk at its iteration boundaries.
       @checkpoint = TurnCheckpoint.new(session: @session, state_dir: @state_dir)