@rubytech/create-sitedesk-code 0.1.511 → 0.1.513

package/payload/platform/scripts/logs-read.sh

@@ -26,7 +26,7 @@
 # For per-session types (agent-stream/system/session/error/public): sessionKey
 # is required in the first mode. For platform-scoped types (server/vnc/
 # heartbeat/mem): the id is ignored. chat-attempts is --tail-only:
-# cross-grep of edge.log + server.log for the chat-ingress quartet within
+# cross-grep of edge.log + server.log for the chat-ingress checkpoints within
 # the most recent N minutes.
 #
 # Every invocation writes a one-line trailer describing files searched,
@@ -154,11 +154,21 @@ is_per_conversation_type() {
 SEARCH_TYPES="agent-stream error session public server mcp vnc"
 VALID_TYPES="agent-stream, system, session, error, heartbeat, public, server, mcp, vnc, mem, chat-attempts"
 
-# chat-attempts cross-grep prefixes. One row per chat-ingress
-# checkpoint emitted across edge.log + server.log: edge-side inbound/outcome,
-# admin-auth gate verdict, chat-route handler entry. Absence of a row at any
-# checkpoint localises the failure to one stage of the ingress pipeline.
-CHAT_ATTEMPT_GREP='\[edge-admin\] inbound|\[edge-admin\] outcome|\[admin-auth\] outcome|\[chat-route\] entered'
+# chat-attempts cross-grep prefixes. Four checkpoint patterns across
+# edge.log + server.log: edge-side inbound/outcome, admin-auth gate verdict,
+# chat-route handler entry. Any one chat emits THREE of the four, and which
+# three depends on the surface: the admin webchat (POST /api/webchat/send)
+# carries an admin-auth row and no chat-route row, public chat
+# (POST /api/chat) carries a chat-route row and no admin-auth row. Absence of
+# a row the surface does emit localises the failure to one ingress stage.
+#
+# The `ts=` group is optional and sits between the tag and the keyword because
+# that is where Task 2024 put it: the shipped line is
+# `[edge-admin] ts=<ISO> inbound …` (edge.ts:188, 199; edge-admin.ts:48, 52).
+# Requiring tag and keyword adjacent matched zero lines and reported the
+# absence as an edge-side silence (Task 2032). Optional rather than required,
+# so the pattern is not pinned to one format version a second time.
+CHAT_ATTEMPT_GREP='\[edge-admin\] (ts=[^ ]+ )?(inbound|outcome)|\[admin-auth\] outcome|\[chat-route\] entered'
 
 # Authoritative sessionKey character set.
 # Writer-side emits `sk_<hex16>` filenames; the underscore must
@@ -179,7 +189,7 @@ Usage:
                                               is_error result (silent-failure audit)
   logs-read.sh --tail [type] [lines]          Tail most recent log of type
   logs-read.sh --tail chat-attempts [min]     Cross-grep edge.log + server.log
-                                              for the chat-ingress quartet
+                                              for the chat-ingress checkpoints
   logs-read.sh --grep <sessionKey> [type]     Legacy grep across log files
 
 Types: $VALID_TYPES
@@ -193,9 +203,12 @@ transcript, flagging subagent is_error results inline. An explicit <type>
 keeps the legacy per-account stream-log read.
 Per-session stream-log types (agent-stream, system, session, error, public)
 require sessionKey; platform-scoped types (server, vnc, heartbeat, mem) ignore the id.
-chat-attempts is --tail-only — it aggregates the four ingress checkpoints
-([edge-admin] inbound, [admin-auth] outcome, [chat-route] entered,
-[edge-admin] outcome) into one timeline.
+chat-attempts is --tail-only — it aggregates four ingress checkpoint patterns
+([edge-admin] ts=<ISO> inbound, [admin-auth] outcome, [chat-route] entered,
+[edge-admin] ts=<ISO> outcome) into one timeline. Any one chat emits three of
+them: the admin webchat (POST /api/webchat/send) emits the two edge rows plus
+[admin-auth] outcome and no [chat-route] row; public chat (POST /api/chat)
+emits the two edge rows plus [chat-route] entered and no [admin-auth] row.
 EOF
   exit 2
 }
@@ -209,25 +222,48 @@ validate_type() {
 }
 
 # chat-attempts cross-grep mode. Combines edge.log + server.log
-# lines matching the chat-ingress quartet, filtered to the last N minutes,
+# lines matching the chat-ingress checkpoints, filtered to the last N minutes,
 # sorted chronologically. Default window: 5 minutes (matches the typical
 # "agent doesn't respond" report window — operator sees the silence,
 # screenshots the chat, then runs this within a few minutes).
 #
 # Output preserves source-file prefix so operators can see whether the line
 # came from the edge process (edge.log) or maxy-ui (server.log). On a
-# successful chat POST the timeline reads:
+# successful chat POST the timeline reads THREE rows, and which three depends
+# on the surface.
+#
+# admin webchat, POST /api/webchat/send:
+#   [edge-admin] ts=… inbound  method=POST path=/api/webchat/send … (edge.log)
+#   [admin-auth] outcome=accept path=/api/webchat/send cacheKey=…   (server.log)
+#   [edge-admin] ts=… outcome  method=POST path=… status=200 …      (edge.log)
+#
+# public chat, POST /api/chat:
+#   [edge-admin] ts=… inbound  method=POST path=/api/chat …         (edge.log)
+#   [chat-route] entered route=public method=POST                   (server.log)
+#   [edge-admin] ts=… outcome  method=POST path=… status=200 …      (edge.log)
+#
+# Nothing emits [chat-route] on the admin surface and nothing emits
+# [admin-auth] on the public one, so the row the OTHER surface would have
+# shown is not evidence of anything. Reading admin against a four-row
+# sequence is what made every healthy admin chat look like a routing
+# regression (Task 2042).
 #
-#   [edge-admin] inbound  method=POST path=/api/admin/chat token=present …  (edge.log)
-#   [admin-auth] outcome=accept …                                           (server.log)
-#   [chat-route] entered  route=admin method=POST cacheKey=… …              (server.log)
-#   [edge-admin] outcome  method=POST path=/api/admin/chat status=200 …     (edge.log)
+# A row missing from the surface's OWN sequence is diagnostic.
+# Both surfaces: zero edge inbound = browser/network problem; edge outcome
+# missing = upstream proxy crash.
+# Admin: [admin-auth] outcome is the handler-side checkpoint. Missing against
+# a present inbound = handler unreachable; outcome=reject = auth failure;
+# outcome=accept already proves the route matched, because requireAdminSession
+# is middleware mounted on /send (webchat.ts), so no further handler-side row
+# is expected.
+# Public: [chat-route] entered is the handler-side checkpoint. Missing against
+# a present inbound for /api/chat = public-route routing regression.
 #
-# Any missing row in that sequence is itself diagnostic. Three-strike rule:
-# zero edge inbound = browser/network problem; inbound present + admin-auth
-# missing = handler unreachable; admin-auth=reject = auth failure; entered
-# missing after accept = Hono routing regression; outcome missing = upstream
-# proxy crash.
+# The two log families are stamped differently and neither is negotiable here:
+# edge.log self-stamps `ts=` inside the line (Task 2024), server.log is stamped
+# at the line start by server-init-line-stamper.cjs. Reading only the leading
+# 19 characters yielded `[edge-admin] ts=202` on every edge line, so the window
+# filter and the sort both have to read whichever form the line carries.
 chat_attempts_mode() {
   local minutes="${1:-5}"
   if ! [[ "$minutes" =~ ^[0-9]+$ ]]; then
@@ -236,57 +272,125 @@ chat_attempts_mode() {
   fi
 
   local EDGE_LOG="$CONFIG_DIR/logs/edge.log"
-  local since_epoch
-  since_epoch=$(date -u -v-"${minutes}"M +%s 2>/dev/null || date -u -d "${minutes} minutes ago" +%s 2>/dev/null || true)
-  if [[ -z "$since_epoch" ]]; then
+  local since_iso
+  since_iso=$(date -u -v-"${minutes}"M +%Y-%m-%dT%H:%M:%S 2>/dev/null || date -u -d "${minutes} minutes ago" +%Y-%m-%dT%H:%M:%S 2>/dev/null || true)
+  if [[ -z "$since_iso" ]]; then
     echo "Error: could not compute time window — neither BSD nor GNU date available" >&2
     exit 2
   fi
 
-  # Each log line carries an ISO-8601 timestamp at the head (server.log via
-  # pino, edge.log via console — both written line-buffered with leading
-  # `YYYY-MM-DDTHH:MM:SS` then either `.sssZ` or a space). awk filters to
-  # the time window; sed prefixes the source filename so the timeline
-  # remains attributable; sort -k1 keeps chronological order.
+  # Emits `<ts>\t<source>\t<line>` into $tmp, where <ts> is the line's own
+  # timestamp to millisecond precision, or `-` when the line carries none.
+  # ISO-8601 UTC strings compare lexicographically in time order, which is why
+  # the window test is a string comparison and not a `date` subprocess per
+  # matched line, which is what the previous form spawned on both dialects.
+  #
+  # Milliseconds are load-bearing, not decoration. Both families emit
+  # `toISOString()`, and a chat's three checkpoints normally complete inside
+  # one wall-clock second, so a key truncated to seconds collides on every row
+  # and the sort falls back to file-append order — which puts the edge rows
+  # first and reproduces the clustering this mode was fixed to stop.
+  #
+  # An undated line reaches $tmp with `-` as its key. It cannot be placed in
+  # the window or in the sequence, so it is listed separately below rather
+  # than merged into the timeline. It is never discarded: a matched line
+  # dropped in silence is the exact fault this mode was fixed for.
   local filter_awk='
-    BEGIN { since = '"$since_epoch"' }
     {
-      ts = substr($0, 1, 19)
-      gsub("T", " ", ts)
-      cmd = "date -u -j -f \"%Y-%m-%d %H:%M:%S\" \"" ts "\" +%s 2>/dev/null || date -u -d \"" ts "\" +%s 2>/dev/null"
-      cmd | getline epoch
-      close(cmd)
-      if (epoch >= since) print
+      ts = "-"
+      if (match($0, /ts=[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9]\.[0-9][0-9][0-9]/)) {
+        ts = substr($0, RSTART + 3, 23)
+      } else if ($0 ~ /^[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9]\.[0-9][0-9][0-9]/) {
+        ts = substr($0, 1, 23)
+      }
+      if (ts == "-" || ts >= since) print ts "\t" src "\t" $0
     }
   '
 
-  local hits=0
   local tmp
   tmp=$(mktemp -t chat-attempts.XXXXXX)
   trap 'rm -f "$tmp"' EXIT
 
   if [[ -f "$EDGE_LOG" ]]; then
-    grep -E "$CHAT_ATTEMPT_GREP" "$EDGE_LOG" 2>/dev/null | awk "$filter_awk" | sed 's|^|edge.log  |' >> "$tmp" || true
+    grep -E "$CHAT_ATTEMPT_GREP" "$EDGE_LOG" 2>/dev/null \
+      | awk -v since="$since_iso" -v src="edge.log" "$filter_awk" >> "$tmp" || true
   fi
   if [[ -f "$SERVER_LOG" ]]; then
-    grep -E "$CHAT_ATTEMPT_GREP" "$SERVER_LOG" 2>/dev/null | awk "$filter_awk" | sed 's|^|server.log|' >> "$tmp" || true
+    grep -E "$CHAT_ATTEMPT_GREP" "$SERVER_LOG" 2>/dev/null \
+      | awk -v since="$since_iso" -v src="server.log" "$filter_awk" >> "$tmp" || true
   fi
 
-  hits=$(wc -l < "$tmp" | tr -d ' ')
-  if [[ "$hits" -eq 0 ]]; then
-    echo "# chat-attempts (last ${minutes} min) — no events" >&2
-    echo "-- trailer: type=chat-attempts window_min=${minutes} matches=0 searched=edge.log,server.log" >&2
+  # Per-source tallies. One aggregate count is what made the miss silent:
+  # `edge=0` folded into the same "no events" line as a genuinely quiet window,
+  # so a reader that could not see the edge read as an edge that said nothing.
+  local counts edge_hits edge_undated server_hits server_undated hits undated
+  counts=$(awk -F'\t' '
+    { if ($1 == "-") u[$2]++; else m[$2]++ }
+    END { printf "%d %d %d %d", m["edge.log"], u["edge.log"], m["server.log"], u["server.log"] }
+  ' "$tmp")
+  read -r edge_hits edge_undated server_hits server_undated <<< "$counts"
+  hits=$((edge_hits + server_hits))
+  undated=$((edge_undated + server_undated))
+
+  local edge_state="present"
+  [[ -f "$EDGE_LOG" ]] || edge_state="absent:$EDGE_LOG"
+  local server_state="present"
+  [[ -f "$SERVER_LOG" ]] || server_state="absent:$SERVER_LOG"
+
+  local trailer="-- trailer: type=chat-attempts window_min=${minutes} matches=${hits} edge=${edge_hits} server=${server_hits} undated=${undated} searched=edge.log,server.log"
+
+  # Nothing matched at all, dated or not. Only here can the mode say anything
+  # about whether a request arrived, and even here only if it could read the
+  # edge log — a file it never opened proves nothing about the traffic.
+  if [[ "$hits" -eq 0 && "$undated" -eq 0 ]]; then
+    echo "# chat-attempts (last ${minutes} min) — no ingress checkpoints matched" >&2
+    echo "#   edge.log=${edge_state} server.log=${server_state}" >&2
+    if [[ -f "$EDGE_LOG" ]]; then
+      # What a genuine zero means, now that the patterns track the shipped
+      # lines: the first checkpoint is the edge accepting a connection, so its
+      # absence places the fault before this device. Saying it here is the
+      # point of the fix — the reader used to produce this same output when it
+      # simply could not see the edge lines.
+      echo "#   The edge patterns track the shipped \`[edge-admin] ts=<ISO> …\` shape, so this" >&2
+      echo "#   is an absence in the logs, not in the reader: no request reached the edge in" >&2
+      echo "#   this window. Look at the browser, DNS, or the tunnel — the admin server is" >&2
+      echo "#   never in the path of a request that never arrived." >&2
+    else
+      echo "#   edge.log is not on disk, so the edge checkpoints could not be read at all." >&2
+      echo "#   This says nothing about whether a request arrived. Check that the edge service" >&2
+      echo "#   is running and writing to the path above before drawing any conclusion." >&2
+    fi
+    echo "$trailer" >&2
     exit 1
   fi
 
-  echo "# chat-attempts (last ${minutes} min — chronological)"
-  echo ""
-  # Sort by the timestamp column that begins immediately after the source-file
-  # prefix. Prefix is "edge.log  " or "server.log" — both 10 chars before the
-  # timestamp begins, so column 11 onward is the chronological key.
-  sort -k1.11 "$tmp"
+  if [[ "$hits" -gt 0 ]]; then
+    echo "# chat-attempts (last ${minutes} min — chronological)"
+    echo ""
+    # Sort on the extracted timestamp column, then drop it. The previous form
+    # sorted on a fixed byte offset that only landed on a timestamp for
+    # server.log lines, so edge rows clustered rather than interleaved. `-s`
+    # keeps edge before server on an exact millisecond tie; LC_ALL=C makes the
+    # byte ordering deterministic across locales.
+    LC_ALL=C sort -t$'\t' -k1,1 -s "$tmp" \
+      | awk -F'\t' '$1 != "-" { printf "%-10s %s\n", $2, $3 }'
+  else
+    echo "# chat-attempts (last ${minutes} min) — no datable checkpoint in the window"
+  fi
+
+  # Matched but undatable. Shown, because a matched edge line is evidence that
+  # a request DID arrive, and suppressing it while reporting silence is how
+  # this mode misread the edge in the first place. Listed in file order and
+  # outside the timeline, because an undated line has no position in it.
+  if [[ "$undated" -gt 0 ]]; then
+    echo ""
+    echo "# ${undated} matched line(s) carry no timestamp and cannot be placed in the window."
+    echo "#   An edge line written before the \`ts=\` stamp carries no clock. File order:"
+    awk -F'\t' '$1 == "-" { printf "%-10s %s\n", $2, $3 }' "$tmp"
+  fi
+
   echo "" >&2
-  echo "-- trailer: type=chat-attempts window_min=${minutes} matches=${hits} searched=edge.log,server.log" >&2
+  echo "$trailer" >&2
   exit 0
 }
 

package/payload/platform/scripts/logs-read.test.sh

@@ -188,11 +188,287 @@ case_mem_absent() {
   return 0
 }
 
+# --- chat-attempts helpers (Task 2032) ---
+# The fixtures are dated off the same clock the script computes its window
+# from, so no case depends on a literal timestamp ageing out.
+iso_minutes_ago() {
+  local m="$1"
+  date -u -v-"${m}"M +%Y-%m-%dT%H:%M:%S 2>/dev/null \
+    || date -u -d "${m} minutes ago" +%Y-%m-%dT%H:%M:%S 2>/dev/null
+}
+
+# --- Case 6 (Task 2032): all four patterns match, interleaved by time ---
+case_chat_attempts_both_surfaces() {
+  local root="/tmp/maxy-logs-read-test-6-$$"
+  local script
+  script=$(setup_install_tree "$root")
+  local logs="$HOME/.$(basename "$root")/logs"
+  # Four checkpoint patterns in one window takes TWO chats, not one: no single
+  # surface emits four (Task 2042). A public chat then an admin chat, three
+  # rows each. Distinct milliseconds inside two minute-slots, so the ordering
+  # assertion below is strict and exercises the millisecond sort key.
+  local tp ta
+  tp=$(iso_minutes_ago 4); ta=$(iso_minutes_ago 2)
+
+  # Shipped shapes: edge.log self-stamps `ts=` after the tag (edge.ts:188,199);
+  # server.log is stamped at the line start by server-init-line-stamper.cjs.
+  # Both edge rows fire for any /api/ path (lib/proxy-log-path.ts:28-30).
+  {
+    echo "[edge-admin] ts=${tp}.100Z inbound method=POST path=/api/chat token=absent allowlist-branch=passthrough"
+    echo "[edge-admin] ts=${tp}.300Z outcome method=POST path=/api/chat status=200 duration_ms=200"
+    echo "[edge-admin] ts=${ta}.100Z inbound method=POST path=/api/webchat/send token=present allowlist-branch=passthrough"
+    echo "[edge-admin] ts=${ta}.300Z outcome method=POST path=/api/webchat/send status=200 duration_ms=200"
+  } > "$logs/edge.log"
+  {
+    echo "${tp}.200Z [chat-route] entered route=public method=POST"
+    echo "${ta}.200Z [admin-auth] outcome=accept path=/api/webchat/send cacheKey=deadbeef…"
+  } > "$logs/server.log"
+
+  local stdout stderr rc=0
+  stdout=$("$script" --tail chat-attempts 5 2>/tmp/maxy-logs-read-stderr-6-$$) || rc=$?
+  stderr=$(cat /tmp/maxy-logs-read-stderr-6-$$)
+  rm -f /tmp/maxy-logs-read-stderr-6-$$
+
+  cleanup_install_tree "$root"
+
+  if [[ $rc -ne 0 ]]; then echo "  expected exit 0, got $rc"; return 1; fi
+  if [[ "$stdout" != *"inbound"* ]]; then echo "  timeline missing edge inbound"; return 1; fi
+  if [[ "$stdout" != *"[edge-admin]"*"outcome"* ]]; then echo "  timeline missing edge outcome"; return 1; fi
+  if [[ "$stdout" != *"[admin-auth] outcome=accept"* ]]; then echo "  timeline missing admin-auth"; return 1; fi
+  if [[ "$stdout" != *"[chat-route] entered route=public"* ]]; then echo "  timeline missing chat-route"; return 1; fi
+  if [[ "$stderr" != *"edge=4"* ]]; then echo "  trailer missing edge=4: $stderr"; return 1; fi
+  if [[ "$stderr" != *"server=2"* ]]; then echo "  trailer missing server=2: $stderr"; return 1; fi
+  if [[ "$stderr" != *"undated=0"* ]]; then echo "  trailer missing undated=0: $stderr"; return 1; fi
+
+  # Chronological across the two log families: the public chat's edge inbound
+  # precedes its chat-route row, which precedes its edge outcome. A fixed-column
+  # sort put the two edge rows adjacent instead, which is the ordering defect
+  # this pins.
+  local first mid last
+  first=$(echo "$stdout" | grep -n 'inbound' | head -1 | cut -d: -f1)
+  mid=$(echo "$stdout" | grep -n '\[chat-route\] entered' | head -1 | cut -d: -f1)
+  last=$(echo "$stdout" | grep -n '\[edge-admin\].*outcome' | head -1 | cut -d: -f1)
+  if [[ -z "$first" || -z "$mid" || -z "$last" ]]; then
+    echo "  could not locate rows: inbound=$first chat-route=$mid outcome=$last"; return 1
+  fi
+  if [[ "$first" -ge "$mid" || "$mid" -ge "$last" ]]; then
+    echo "  rows not in chronological order: inbound=$first chat-route=$mid outcome=$last"
+    return 1
+  fi
+  return 0
+}
+
+# --- Case 7 (Task 2032): genuine zero says so distinctly ---
+case_chat_attempts_genuine_zero() {
+  local root="/tmp/maxy-logs-read-test-7-$$"
+  local script
+  script=$(setup_install_tree "$root")
+  local logs="$HOME/.$(basename "$root")/logs"
+  local t0
+  t0=$(iso_minutes_ago 1)
+  # Both files exist and hold traffic; none of it is a chat-ingress checkpoint.
+  echo "[edge] ts=${t0}.000Z upstream http error path=/api/whatsapp err=ECONNREFUSED err-class=econnrefused-coldstart upstream=127.0.0.1:19201" > "$logs/edge.log"
+  echo "${t0}.000Z [server-init] watchdog enabled (ping-interval-ms=15000 deadline-ms=30000)" > "$logs/server.log"
+
+  local stderr rc=0
+  "$script" --tail chat-attempts 5 >/dev/null 2>/tmp/maxy-logs-read-stderr-7-$$ || rc=$?
+  stderr=$(cat /tmp/maxy-logs-read-stderr-7-$$)
+  rm -f /tmp/maxy-logs-read-stderr-7-$$
+
+  cleanup_install_tree "$root"
+
+  if [[ $rc -ne 1 ]]; then echo "  expected exit 1, got $rc"; return 1; fi
+  if [[ "$stderr" != *"edge=0"* || "$stderr" != *"server=0"* ]]; then
+    echo "  trailer missing per-source zeroes: $stderr"; return 1
+  fi
+  if [[ "$stderr" != *"no request reached the edge"* ]]; then
+    echo "  zero-hit message does not state what a genuine zero means: $stderr"; return 1
+  fi
+  return 0
+}
+
+# --- Case 8 (Task 2032): the window excludes an older edge line ---
+case_chat_attempts_window() {
+  local root="/tmp/maxy-logs-read-test-8-$$"
+  local script
+  script=$(setup_install_tree "$root")
+  local logs="$HOME/.$(basename "$root")/logs"
+  local recent old
+  recent=$(iso_minutes_ago 1)
+  old=$(iso_minutes_ago 90)
+  {
+    echo "[edge-admin] ts=${old}.000Z inbound method=POST path=/api/webchat/send token=present allowlist-branch=passthrough"
+    echo "[edge-admin] ts=${recent}.000Z inbound method=GET path=/api/admin/version token=absent allowlist-branch=passthrough"
+  } > "$logs/edge.log"
+  : > "$logs/server.log"
+
+  local stdout stderr rc=0
+  stdout=$("$script" --tail chat-attempts 5 2>/tmp/maxy-logs-read-stderr-8-$$) || rc=$?
+  stderr=$(cat /tmp/maxy-logs-read-stderr-8-$$)
+  rm -f /tmp/maxy-logs-read-stderr-8-$$
+
+  cleanup_install_tree "$root"
+
+  if [[ $rc -ne 0 ]]; then echo "  expected exit 0, got $rc"; return 1; fi
+  if [[ "$stdout" == *"$old"* ]]; then echo "  out-of-window line was not filtered"; return 1; fi
+  if [[ "$stdout" != *"$recent"* ]]; then echo "  in-window line missing"; return 1; fi
+  if [[ "$stderr" != *"edge=1"* ]]; then echo "  trailer edge count wrong: $stderr"; return 1; fi
+  return 0
+}
+
+# --- Case 9 (Task 2032): all four patterns inside one second still order ---
+# A chat POST completes in a few hundred milliseconds, so its checkpoints share
+# a wall-clock second; an admin chat and a public chat overlapping in that same
+# second put all four patterns there at once. A sort key truncated to seconds
+# collides on every row and falls back to file-append order, which puts the edge
+# rows first — the clustering this mode was fixed to stop. Six rows, because no
+# single surface emits four checkpoints (Task 2042).
+case_chat_attempts_subsecond_order() {
+  local root="/tmp/maxy-logs-read-test-9-$$"
+  local script
+  script=$(setup_install_tree "$root")
+  local logs="$HOME/.$(basename "$root")/logs"
+  local s
+  s=$(iso_minutes_ago 1)
+  {
+    echo "[edge-admin] ts=${s}.010Z inbound method=POST path=/api/webchat/send token=present allowlist-branch=passthrough"
+    echo "[edge-admin] ts=${s}.060Z inbound method=POST path=/api/chat token=absent allowlist-branch=passthrough"
+    echo "[edge-admin] ts=${s}.090Z outcome method=POST path=/api/chat status=200 duration_ms=30"
+    echo "[edge-admin] ts=${s}.230Z outcome method=POST path=/api/webchat/send status=200 duration_ms=220"
+  } > "$logs/edge.log"
+  {
+    echo "${s}.050Z [admin-auth] outcome=accept path=/api/webchat/send cacheKey=deadbeef"
+    echo "${s}.070Z [chat-route] entered route=public method=POST"
+  } > "$logs/server.log"
+
+  local stdout rc=0
+  stdout=$("$script" --tail chat-attempts 5 2>/dev/null) || rc=$?
+
+  cleanup_install_tree "$root"
+
+  if [[ $rc -ne 0 ]]; then echo "  expected exit 0, got $rc"; return 1; fi
+  local n_in n_auth n_route n_out
+  n_in=$(echo "$stdout" | grep -n 'inbound' | head -1 | cut -d: -f1)
+  n_auth=$(echo "$stdout" | grep -n '\[admin-auth\]' | head -1 | cut -d: -f1)
+  n_route=$(echo "$stdout" | grep -n '\[chat-route\]' | head -1 | cut -d: -f1)
+  n_out=$(echo "$stdout" | grep -n '\[edge-admin\].*outcome' | head -1 | cut -d: -f1)
+  if [[ -z "$n_in" || -z "$n_auth" || -z "$n_route" || -z "$n_out" ]]; then
+    echo "  missing a row: in=$n_in auth=$n_auth route=$n_route out=$n_out"; return 1
+  fi
+  if [[ "$n_in" -ge "$n_auth" || "$n_auth" -ge "$n_route" || "$n_route" -ge "$n_out" ]]; then
+    echo "  sub-second rows out of order: in=$n_in auth=$n_auth route=$n_route out=$n_out"
+    echo "$stdout"
+    return 1
+  fi
+  return 0
+}
+
+# --- Case 10 (Task 2032): an undated match is never narrated as edge silence ---
+# The grep matches the `[edge-admin] inbound` shape written before the `ts=`
+# no timestamp. Such a line cannot be placed in the window, but it is evidence
+# that a request DID reach the edge, so the mode must not answer with the
+# genuine-zero verdict.
+case_chat_attempts_undated_not_silence() {
+  local root="/tmp/maxy-logs-read-test-10-$$"
+  local script
+  script=$(setup_install_tree "$root")
+  local logs="$HOME/.$(basename "$root")/logs"
+  echo "[edge-admin] inbound method=POST path=/api/webchat/send token=present allowlist-branch=passthrough" > "$logs/edge.log"
+  : > "$logs/server.log"
+
+  local stdout stderr rc=0
+  stdout=$("$script" --tail chat-attempts 5 2>/tmp/maxy-logs-read-stderr-10-$$) || rc=$?
+  stderr=$(cat /tmp/maxy-logs-read-stderr-10-$$)
+  rm -f /tmp/maxy-logs-read-stderr-10-$$
+
+  cleanup_install_tree "$root"
+
+  if [[ $rc -ne 0 ]]; then echo "  expected exit 0 (a match is a match), got $rc"; return 1; fi
+  if [[ "$stderr" == *"no request reached the edge"* || "$stdout" == *"no request reached the edge"* ]]; then
+    echo "  matched an edge line and still claimed no request reached the edge"; return 1
+  fi
+  if [[ "$stdout" != *"carry no timestamp"* ]]; then
+    echo "  undated match not surfaced in the output: $stdout"; return 1
+  fi
+  if [[ "$stdout" != *"[edge-admin] inbound"* ]]; then
+    echo "  undated line itself not printed"; return 1
+  fi
+  if [[ "$stderr" != *"undated=1"* ]]; then echo "  trailer undated count wrong: $stderr"; return 1; fi
+  return 0
+}
+
+# --- Case 11 (Task 2032): a missing edge.log is reader blindness, not silence ---
+case_chat_attempts_edge_log_absent() {
+  local root="/tmp/maxy-logs-read-test-11-$$"
+  local script
+  script=$(setup_install_tree "$root")
+  local logs="$HOME/.$(basename "$root")/logs"
+  # server.log exists, edge.log does not.
+  : > "$logs/server.log"
+  rm -f "$logs/edge.log"
+
+  local stderr rc=0
+  "$script" --tail chat-attempts 5 >/dev/null 2>/tmp/maxy-logs-read-stderr-11-$$ || rc=$?
+  stderr=$(cat /tmp/maxy-logs-read-stderr-11-$$)
+  rm -f /tmp/maxy-logs-read-stderr-11-$$
+
+  cleanup_install_tree "$root"
+
+  if [[ $rc -ne 1 ]]; then echo "  expected exit 1, got $rc"; return 1; fi
+  if [[ "$stderr" == *"no request reached the edge"* ]]; then
+    echo "  claimed no request arrived while edge.log was unreadable"; return 1
+  fi
+  if [[ "$stderr" != *"edge.log is not on disk"* ]]; then
+    echo "  did not state that the edge checkpoints were unreadable: $stderr"; return 1
+  fi
+  return 0
+}
+
+# --- Case 12 (Task 2042): usage names each surface, not four rows per chat ---
+# The mode greps four checkpoint patterns, but no single chat emits four: the
+# admin webchat has no [chat-route] row and public chat has no [admin-auth]
+# row. Usage that promised four made every healthy admin chat read as a
+# routing regression, so the count and both surface paths are pinned here.
+case_usage_checkpoints_per_surface() {
+  local root="/tmp/maxy-logs-read-test-12-$$"
+  local script
+  script=$(setup_install_tree "$root")
+
+  local stderr rc=0
+  "$script" >/dev/null 2>/tmp/maxy-logs-read-stderr-12-$$ || rc=$?
+  stderr=$(cat /tmp/maxy-logs-read-stderr-12-$$)
+  rm -f /tmp/maxy-logs-read-stderr-12-$$
+
+  cleanup_install_tree "$root"
+
+  if [[ $rc -ne 2 ]]; then echo "  expected usage exit 2, got $rc"; return 1; fi
+  if [[ "$stderr" == *"four ingress checkpoints"* ]]; then
+    echo "  usage still claims four checkpoints per chat"; return 1
+  fi
+  if [[ "$stderr" == *"quartet"* ]]; then
+    echo "  usage still calls the checkpoints a quartet"; return 1
+  fi
+  if [[ "$stderr" != *"/api/webchat/send"* ]]; then
+    echo "  usage does not name the admin surface path"; return 1
+  fi
+  if [[ "$stderr" != *"/api/chat"* ]]; then
+    echo "  usage does not name the public surface path"; return 1
+  fi
+  return 0
+}
+
 run_case "sessionKey file present → exit 0" case_file_present
 run_case "no file → exit 1 + missing-on-resolve" case_missing
 run_case "ambiguous prefix → exit 1, refuses to pick" case_ambiguous
 run_case "--tail mem present → exit 0 + sampler lines" case_mem_present
 run_case "--tail mem absent → exit 1 + not-found message" case_mem_absent
+run_case "chat-attempts matches both surfaces and interleaves" case_chat_attempts_both_surfaces
+run_case "chat-attempts genuine zero states what it means" case_chat_attempts_genuine_zero
+run_case "chat-attempts window excludes an older line" case_chat_attempts_window
+run_case "chat-attempts orders all four patterns inside one second" case_chat_attempts_subsecond_order
+run_case "chat-attempts undated match is not edge silence" case_chat_attempts_undated_not_silence
+run_case "chat-attempts absent edge.log is reader blindness" case_chat_attempts_edge_log_absent
+run_case "usage names each surface's checkpoints" case_usage_checkpoints_per_surface
 
 echo ""
 echo "================================================"

package/payload/platform/scripts/provision-worktree.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+# The one documented action that makes a fresh worktree able to run the
+# platform/ui suite. Task 2034.
+#
+# A git worktree carries tracked files only. platform/node_modules,
+# platform/ui/node_modules and platform/lib/*/dist are gitignored build output, so
+# a fresh worktree has none of them, and `npm install` inside platform/ui creates
+# neither the hoisted platform/node_modules nor any lib dist. Without this, the
+# suite fails on absent artifacts in a way that reads as flaky tests.
+#
+# Two things here are not obvious and are the reason this is a script:
+#
+#   1. tsc is called as platform/node_modules/.bin/tsc, never bare. platform's
+#      own package.json declares no typescript; it hoists one from 28 workspace
+#      members. Inside an npm script npm prepends node_modules/.bin to PATH and a
+#      bare `tsc` resolves; from a bare shell it does not, and the tsc on PATH is
+#      an unrelated program that refuses to run.
+#
+#   2. The libs are built in a loop, not through `npm run build:lib`. build:lib
+#      chains its 27 compiler runs with &&, and one lib emits its output while
+#      still reporting type errors, which would abort every run after it. So each
+#      lib is built independently and the final gate is artifact presence, not
+#      compiler exit status — the only check that separates "emitted with type
+#      errors" from "emitted nothing".
+
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
+PLATFORM="$(cd "$SCRIPT_DIR/.." && pwd -P)"
+TSC="$PLATFORM/node_modules/.bin/tsc"
+GATE="$PLATFORM/ui/scripts/check-worktree-provisioned.mjs"
+
+echo "[provision] platform: $PLATFORM"
+
+echo "[provision] stage 1/3: npm install in platform/"
+if ! (cd "$PLATFORM" && npm install); then
+  echo "[provision] FAILED at stage 1: npm install in platform/" >&2
+  exit 1
+fi
+
+echo "[provision] stage 2/3: npm install in platform/ui"
+if ! (cd "$PLATFORM/ui" && npm install); then
+  echo "[provision] FAILED at stage 2: npm install in platform/ui" >&2
+  exit 1
+fi
+
+if [ ! -x "$TSC" ]; then
+  echo "[provision] FAILED: $TSC absent after stage 1." >&2
+  echo "[provision] typescript hoists to platform/node_modules from the workspace" >&2
+  echo "[provision] members; if it is missing, stage 1 did not complete." >&2
+  exit 1
+fi
+
+echo "[provision] stage 3/3: building platform/lib/*/dist"
+emitted_with_errors=()
+for tsconfig in "$PLATFORM"/lib/*/tsconfig.json; do
+  lib="$(basename "$(dirname "$tsconfig")")"
+  if "$TSC" -p "$tsconfig" >/dev/null 2>&1; then
+    printf '  %-32s ok\n' "$lib"
+  elif [ -f "$PLATFORM/lib/$lib/dist/index.js" ]; then
+    printf '  %-32s emitted, with type errors\n' "$lib"
+    emitted_with_errors+=("$lib")
+  else
+    printf '  %-32s FAILED, emitted nothing\n' "$lib"
+  fi
+done
+
+if [ ${#emitted_with_errors[@]} -gt 0 ]; then
+  echo "[provision] ${#emitted_with_errors[@]} lib(s) emitted output while reporting type"
+  echo "[provision] errors: ${emitted_with_errors[*]}. Their dist is present, so the suite"
+  echo "[provision] can run. The type errors themselves are out of scope for provisioning."
+fi
+
+echo "[provision] verifying against the gate"
+if ! node "$GATE"; then
+  echo "[provision] FAILED: the tree is still unprovisioned after all three stages." >&2
+  exit 1
+fi
+
+echo "[provision] done. platform/ui is ready: cd platform/ui && npm test"