@rubytech/create-sitedesk-code 0.1.507 → 0.1.509

package/payload/platform/scripts/__tests__/check-brand-cache.test.sh

@@ -0,0 +1,231 @@
+#!/usr/bin/env bash
+# Tests for check-brand-cache.sh (Task 2019). Fixture-driven: builds a throwaway
+# install dir + config dir per case and stubs the fetch command, because the real
+# one crosses a Cloudflare edge that no test can hold still. sha256 and the
+# ingress parse are the real code paths — those are what this asserts.
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CHECK="$SCRIPT_DIR/../check-brand-cache.sh"
+
+PASS=0
+FAIL=0
+
+run_case() {
+  local name="$1"; shift
+  echo ""
+  echo "=== CASE: $name ==="
+  if "$@"; then
+    PASS=$((PASS + 1)); echo "PASS: $name"
+  else
+    FAIL=$((FAIL + 1)); echo "FAIL: $name"
+  fi
+}
+
+# Build install dir with two brand files and brand-defaults.css. Echoes its path.
+mk_install() {
+  local d
+  d="$(mktemp -d "${TMPDIR:-/tmp}/brand-cache-install.XXXXXX")"
+  mkdir -p "$d/server/public/brand"
+  printf 'lime-logo-bytes' > "$d/server/public/brand/logo.png"
+  printf 'lime-icon-bytes' > "$d/server/public/brand/icon.png"
+  printf ':root{--brand:#c3f53c}' > "$d/server/public/brand-defaults.css"
+  echo "$d"
+}
+
+# Build a config dir whose cloudflared/config.yml has the given ingress hosts.
+mk_config_with_hosts() {
+  local d; d="$(mktemp -d "${TMPDIR:-/tmp}/brand-cache-config.XXXXXX")"
+  mkdir -p "$d/cloudflared"
+  { echo "ingress:"; for h in "$@"; do echo "  - hostname: $h"; done; echo "  - service: http_status:404"; } \
+    > "$d/cloudflared/config.yml"
+  echo "$d"
+}
+
+mk_config_no_tunnel() {
+  local d; d="$(mktemp -d "${TMPDIR:-/tmp}/brand-cache-config.XXXXXX")"
+  echo "$d"
+}
+
+# A config dir with no cloudflared ingress but an alias-domains.json, the
+# second source resolvePublicHostname reads.
+mk_config_alias_only() {
+  local d; d="$(mktemp -d "${TMPDIR:-/tmp}/brand-cache-config.XXXXXX")"
+  printf '["public.realagent.app"]' > "$d/alias-domains.json"
+  echo "$d"
+}
+
+# Stub curl. $1 = dir whose files it serves as the "edge", keyed by basename.
+# Writes headers to the -D path and the body to the -o path, exit 0.
+mk_curl_stub() {
+  local serve_dir="$1" stub
+  stub="$(mktemp "${TMPDIR:-/tmp}/brand-cache-curl.XXXXXX")"
+  cat > "$stub" <<STUB
+#!/usr/bin/env bash
+hdr=""; out=""; url=""
+while [ \$# -gt 0 ]; do
+  case "\$1" in
+    -D) hdr="\$2"; shift 2 ;;
+    -o) out="\$2"; shift 2 ;;
+    -*) shift ;;
+    *) url="\$1"; shift ;;
+  esac
+done
+name="\${url##*/}"
+printf 'HTTP/2 200\r\ncf-cache-status: HIT\r\nage: 5352\r\n\r\n' > "\$hdr"
+cat "$serve_dir/\$name" > "\$out"
+STUB
+  chmod +x "$stub"
+  echo "$stub"
+}
+
+case_clean_install_reports_clean() {
+  local i c stub edge out rc
+  i="$(mk_install)"; c="$(mk_config_with_hosts operations.realagent.network)"
+  # Edge serves exactly what is on disk.
+  edge="$(mktemp -d "${TMPDIR:-/tmp}/brand-cache-edge.XXXXXX")"
+  cp "$i/server/public/brand/"* "$edge/"
+  cp "$i/server/public/brand-defaults.css" "$edge/"
+  stub="$(mk_curl_stub "$edge")"
+  out="$(BRAND_CACHE_CURL="$stub" "$CHECK" --install-dir "$i" --config-dir "$c" 2>/dev/null)"
+  rc=$?
+  [ "$rc" -eq 0 ] || { echo "  expected exit 0, got $rc"; rm -rf "$i" "$c" "$edge" "$stub"; return 1; }
+  # files=2 pinned as an integer: a \d+ match also accepts files=0, and a
+  # hostname resolving to nothing would then read as a pass.
+  echo "$out" | grep -qx "\[brand-cache\] clean host=operations.realagent.network files=2" \
+    || { echo "  no clean line with files=2; got: $out"; rm -rf "$i" "$c" "$edge" "$stub"; return 1; }
+  rm -rf "$i" "$c" "$edge" "$stub"; return 0
+}
+
+case_stale_edge_reports_stale_on_stderr() {
+  local i c stub edge err rc
+  i="$(mk_install)"; c="$(mk_config_with_hosts operations.realagent.network)"
+  edge="$(mktemp -d "${TMPDIR:-/tmp}/brand-cache-edge.XXXXXX")"
+  cp "$i/server/public/brand/"* "$edge/"
+  cp "$i/server/public/brand-defaults.css" "$edge/"
+  # The measured symptom: the edge holds the retired mark, disk holds the new one.
+  printf 'black-square-bytes' > "$edge/logo.png"
+  stub="$(mk_curl_stub "$edge")"
+  err="$(BRAND_CACHE_CURL="$stub" "$CHECK" --install-dir "$i" --config-dir "$c" 2>&1 >/dev/null)"
+  rc=$?
+  [ "$rc" -eq 1 ] || { echo "  expected exit 1, got $rc"; rm -rf "$i" "$c" "$edge" "$stub"; return 1; }
+  echo "$err" | grep -qE "^\[brand-cache\] STALE host=operations\.realagent\.network path=/brand/logo\.png edge=[0-9a-f]{7} disk=[0-9a-f]{7} cf-cache-status=HIT age=5352$" \
+    || { echo "  no STALE line for /brand/logo.png; got: $err"; rm -rf "$i" "$c" "$edge" "$stub"; return 1; }
+  rm -rf "$i" "$c" "$edge" "$stub"; return 0
+}
+
+case_no_tunnel_reports_skipped() {
+  local i c out rc
+  i="$(mk_install)"; c="$(mk_config_no_tunnel)"
+  out="$("$CHECK" --install-dir "$i" --config-dir "$c" 2>/dev/null)"
+  rc=$?
+  [ "$rc" -eq 0 ] || { echo "  expected exit 0, got $rc"; rm -rf "$i" "$c"; return 1; }
+  echo "$out" | grep -qx "\[brand-cache\] skipped host=none reason=no-tunnel-ingress" \
+    || { echo "  no skipped line; got: $out"; rm -rf "$i" "$c"; return 1; }
+  rm -rf "$i" "$c"; return 0
+}
+
+case_localhost_only_ingress_is_no_tunnel() {
+  local i c out rc
+  i="$(mk_install)"; c="$(mk_config_with_hosts localhost muvin.local)"
+  out="$("$CHECK" --install-dir "$i" --config-dir "$c" 2>/dev/null)"
+  rc=$?
+  [ "$rc" -eq 0 ] || { echo "  expected exit 0, got $rc"; rm -rf "$i" "$c"; return 1; }
+  echo "$out" | grep -qx "\[brand-cache\] skipped host=none reason=no-tunnel-ingress" \
+    || { echo "  localhost/.local counted as ingress; got: $out"; rm -rf "$i" "$c"; return 1; }
+  rm -rf "$i" "$c"; return 0
+}
+
+case_unfetchable_asset_is_not_silently_clean() {
+  local i c stub err rc
+  i="$(mk_install)"; c="$(mk_config_with_hosts operations.realagent.network)"
+  # Stub that answers 502 with an empty body for every path.
+  stub="$(mktemp "${TMPDIR:-/tmp}/brand-cache-curl.XXXXXX")"
+  cat > "$stub" <<'STUB'
+#!/usr/bin/env bash
+hdr=""; out=""
+while [ $# -gt 0 ]; do
+  case "$1" in
+    -D) hdr="$2"; shift 2 ;;
+    -o) out="$2"; shift 2 ;;
+    -*) shift ;;
+    *) shift ;;
+  esac
+done
+printf 'HTTP/2 502\r\n\r\n' > "$hdr"
+: > "$out"
+STUB
+  chmod +x "$stub"
+  err="$(BRAND_CACHE_CURL="$stub" "$CHECK" --install-dir "$i" --config-dir "$c" 2>&1 >/dev/null)"
+  rc=$?
+  [ "$rc" -eq 1 ] || { echo "  expected exit 1, got $rc"; rm -rf "$i" "$c" "$stub"; return 1; }
+  echo "$err" | grep -qE "^\[brand-cache\] UNREACHABLE host=operations\.realagent\.network path=/brand/logo\.png http=502$" \
+    || { echo "  no UNREACHABLE line; got: $err"; rm -rf "$i" "$c" "$stub"; return 1; }
+  rm -rf "$i" "$c" "$stub"; return 0
+}
+
+case_no_assets_is_a_named_skip_not_a_clean() {
+  local i c out rc
+  i="$(mktemp -d "${TMPDIR:-/tmp}/brand-cache-install.XXXXXX")"; mkdir -p "$i/server/public"
+  c="$(mk_config_with_hosts operations.realagent.network)"
+  # bash 3.2 (macOS) errors on "${PATHS[@]}" for an empty array under `set -u`,
+  # so this also pins that the loop is never entered with nothing to compare.
+  out="$(/bin/bash "$CHECK" --install-dir "$i" --config-dir "$c" 2>&1)"
+  rc=$?
+  [ "$rc" -eq 0 ] || { echo "  expected exit 0, got $rc; got: $out"; rm -rf "$i" "$c"; return 1; }
+  echo "$out" | grep -qx "\[brand-cache\] skipped host=operations.realagent.network reason=no-brand-assets" \
+    || { echo "  no named skip for an empty asset list; got: $out"; rm -rf "$i" "$c"; return 1; }
+  # files=0 must never be emitted: the task's own pinning exists so an empty
+  # comparison cannot read as a pass.
+  echo "$out" | grep -q "files=0" \
+    && { echo "  emitted files=0, which reads as a pass"; rm -rf "$i" "$c"; return 1; }
+  rm -rf "$i" "$c"; return 0
+}
+
+case_alias_only_install_is_checked_not_skipped() {
+  local i c stub edge out rc
+  i="$(mk_install)"; c="$(mk_config_alias_only)"
+  edge="$(mktemp -d "${TMPDIR:-/tmp}/brand-cache-edge.XXXXXX")"
+  cp "$i/server/public/brand/"* "$edge/"
+  stub="$(mk_curl_stub "$edge")"
+  out="$(BRAND_CACHE_CURL="$stub" "$CHECK" --install-dir "$i" --config-dir "$c" 2>/dev/null)"
+  rc=$?
+  [ "$rc" -eq 0 ] || { echo "  expected exit 0, got $rc"; rm -rf "$i" "$c" "$edge" "$stub"; return 1; }
+  # An install with an alias edge and no ingress row does have an edge that can
+  # diverge, so reporting `skipped` there would read as nothing-to-check on the
+  # one state the skip wording promises it is not.
+  echo "$out" | grep -qx "\[brand-cache\] clean host=public.realagent.app files=2" \
+    || { echo "  alias-only install was not checked; got: $out"; rm -rf "$i" "$c" "$edge" "$stub"; return 1; }
+  rm -rf "$i" "$c" "$edge" "$stub"; return 0
+}
+
+case_brand_defaults_css_is_not_fetched() {
+  local i c stub edge out rc
+  i="$(mk_install)"; c="$(mk_config_with_hosts admin.realagent.network public.realagent.network)"
+  edge="$(mktemp -d "${TMPDIR:-/tmp}/brand-cache-edge.XXXXXX")"
+  cp "$i/server/public/brand/"* "$edge/"
+  # No brand-defaults.css at the edge. The gate at server/index.ts:1311-1322
+  # exempts /brand/ but not /brand-defaults.css, so through an admin-gated host
+  # that path answers with a login page at status 200 — hashing that against
+  # the stylesheet would be a permanent false STALE with no cache involved.
+  stub="$(mk_curl_stub "$edge")"
+  out="$(BRAND_CACHE_CURL="$stub" "$CHECK" --install-dir "$i" --config-dir "$c" 2>/dev/null)"
+  rc=$?
+  [ "$rc" -eq 0 ] || { echo "  expected exit 0, got $rc"; rm -rf "$i" "$c" "$edge" "$stub"; return 1; }
+  echo "$out" | grep -qx "\[brand-cache\] clean host=admin.realagent.network files=2" \
+    || { echo "  expected only the two /brand/ files; got: $out"; rm -rf "$i" "$c" "$edge" "$stub"; return 1; }
+  rm -rf "$i" "$c" "$edge" "$stub"; return 0
+}
+
+run_case "clean install reports clean with a pinned file count" case_clean_install_reports_clean
+run_case "stale edge reports STALE on stderr and exits 1" case_stale_edge_reports_stale_on_stderr
+run_case "no tunnel ingress reports skipped and exits 0" case_no_tunnel_reports_skipped
+run_case "localhost/.local-only ingress counts as no tunnel" case_localhost_only_ingress_is_no_tunnel
+run_case "an unfetchable asset is reported, never counted clean" case_unfetchable_asset_is_not_silently_clean
+run_case "an empty asset list is a named skip, never files=0" case_no_assets_is_a_named_skip_not_a_clean
+run_case "an alias-only install is checked, not skipped" case_alias_only_install_is_checked_not_skipped
+run_case "brand-defaults.css is not fetched through a gated host" case_brand_defaults_css_is_not_fetched
+
+echo ""
+echo "PASS=$PASS FAIL=$FAIL"
+[ "$FAIL" -eq 0 ]

package/payload/platform/scripts/__tests__/provision-honours-disabled-agents.test.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# Task 1996 — an upgrade must not re-deliver an agent the operator switched off.
+#
+# provision_account_dir wipes every core specialist and re-copies it from the
+# bundled templates on every run. Without this, disabling an agent lapses on the
+# next publish: the file reappears in the dispatchable directory, nothing logs,
+# and the card still reads "disabled". That is the no-event failure the task
+# names, so it is pinned here.
+set -uo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PLAT_SCRIPTS="$SCRIPT_DIR/.."
+PROJECT_DIR="$(cd "$PLAT_SCRIPTS/.." && pwd)"
+TEMPLATES_DIR="$PROJECT_DIR/templates"
+PASS=0; FAIL=0; FAILED=()
+assert_absent() { if [ ! -e "$1" ]; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); FAILED+=("$2: expected absent [$1]"); fi; }
+assert_present() { if [ -e "$1" ]; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); FAILED+=("$2: expected present [$1]"); fi; }
+assert_eq() { if [ "$1" = "$2" ]; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); FAILED+=("$3: expected [$2] got [$1]"); fi; }
+
+. "$PLAT_SCRIPTS/lib/provision-account-dir.sh"
+export TEMPLATES_DIR PROJECT_DIR
+export SCRIPT_DIR="$PLAT_SCRIPTS"
+export USERS_FILE="/nonexistent/users.json"
+
+# A real shipped specialist, so the test exercises the same wipe-and-recopy loop
+# a publish runs rather than a synthetic filename.
+DISABLED_AGENT="coding-assistant.md"
+
+T1=$(mktemp -d); A1="$T1/acct"
+provision_account_dir "$A1" "dddddddd-dddd-dddd-dddd-dddddddddddd" "house" >/dev/null 2>&1
+assert_present "$A1/specialists/agents/$DISABLED_AGENT" "baseline-agent-delivered"
+
+# The operator disables it: the file moves to quarantine and the store names it.
+mkdir -p "$A1/specialists/agents-disabled"
+mv "$A1/specialists/agents/$DISABLED_AGENT" "$A1/specialists/agents-disabled/$DISABLED_AGENT"
+printf '{"disabled":["%s"]}\n' "$DISABLED_AGENT" > "$A1/agents-disabled.json"
+
+# The upgrade runs again.
+OUT="$(provision_account_dir "$A1" "dddddddd-dddd-dddd-dddd-dddddddddddd" "house" 2>&1)"
+
+assert_absent "$A1/specialists/agents/$DISABLED_AGENT" "disabled-agent-not-redelivered"
+assert_present "$A1/specialists/agents-disabled/$DISABLED_AGENT" "quarantined-copy-survives-upgrade"
+# Every other core specialist is still delivered: the guard removes what the
+# operator named, not the whole set.
+assert_present "$A1/specialists/agents/librarian.md" "other-agents-still-delivered"
+# The removal is reported, so an operator reading the publish output can see
+# which agents provisioning deliberately withheld.
+assert_eq "$(printf '%s' "$OUT" | grep -c "agents-withheld=1")" "1" "withheld-count-logged"
+rm -rf "$T1"
+
+# No store, no behaviour change: every core specialist is delivered.
+T2=$(mktemp -d); A2="$T2/acct"
+provision_account_dir "$A2" "eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee" "house" >/dev/null 2>&1
+assert_present "$A2/specialists/agents/$DISABLED_AGENT" "no-store-delivers-everything"
+rm -rf "$T2"
+
+# A malformed store withholds nothing rather than withholding everything: an
+# unreadable file is not evidence that the operator disabled an agent.
+T3=$(mktemp -d); A3="$T3/acct"
+provision_account_dir "$A3" "ffffffff-ffff-ffff-ffff-ffffffffffff" "house" >/dev/null 2>&1
+printf '{ not json\n' > "$A3/agents-disabled.json"
+OUT3="$(provision_account_dir "$A3" "ffffffff-ffff-ffff-ffff-ffffffffffff" "house" 2>&1)"
+assert_present "$A3/specialists/agents/$DISABLED_AGENT" "malformed-store-withholds-nothing"
+assert_eq "$(printf '%s' "$OUT3" | grep -c 'agents-disabled-store-unreadable')" "1" "malformed-store-reported"
+rm -rf "$T3"
+
+# Review finding: the withhold used `rm -f` unconditionally. In the drift state
+# the reconcile check exists to catch — store names it, file is live, quarantine
+# empty — that deletes the only copy of a premium `--` agent or an operator-edited
+# override, because the replace loop skips `*--*` and the copy loop only restores
+# templates. Withholding must move, never destroy.
+T4=$(mktemp -d); A4="$T4/acct"
+provision_account_dir "$A4" "aaaa1111-aaaa-1111-aaaa-111111111111" "house" >/dev/null 2>&1
+mkdir -p "$A4/specialists/agents"
+printf -- '---\nname: quoter\n---\n\nOperator edited this premium agent.\n' > "$A4/specialists/agents/sitedesk--quoter.md"
+printf '{"disabled":["sitedesk--quoter.md"]}\n' > "$A4/agents-disabled.json"
+provision_account_dir "$A4" "aaaa1111-aaaa-1111-aaaa-111111111111" "house" >/dev/null 2>&1
+
+assert_absent "$A4/specialists/agents/sitedesk--quoter.md" "premium-withheld-from-dispatch"
+assert_present "$A4/specialists/agents-disabled/sitedesk--quoter.md" "premium-preserved-not-destroyed"
+assert_eq "$(grep -c 'Operator edited this premium agent' "$A4/specialists/agents-disabled/sitedesk--quoter.md" 2>/dev/null || echo 0)" "1" "premium-content-intact"
+rm -rf "$T4"
+
+echo "PASS=$PASS FAIL=$FAIL"
+if [ "$FAIL" -gt 0 ]; then printf '%s\n' "${FAILED[@]}"; exit 1; fi

package/payload/platform/scripts/check-brand-cache.sh

@@ -0,0 +1,138 @@
+#!/usr/bin/env bash
+# check-brand-cache.sh — reconcile the bytes the public hostname returns
+# against the bytes on disk (Task 2019).
+#
+# The failure this exists for emits no event at either end. The installer
+# writes the new brand bytes and logs a successful upgrade; the origin serves
+# them correctly to anyone asking it directly; Cloudflare's edge serves the
+# pre-upgrade ones and reports `HIT` to nobody looking. There is no action to
+# log and re-running the upgrade does not surface it, so only a reconciliation
+# of served bytes against on-disk bytes reveals the state. That is the
+# condition behind the 2026-07-26 report, where the regenerated Real Agent logo
+# was correct on disk and invisible through the hostname for four hours.
+#
+#   $ check-brand-cache.sh --install-dir <dir> --config-dir <dir>
+#
+# stdout, exit 0:  [brand-cache] clean host=<h> files=<n>
+# stdout, exit 0:  [brand-cache] skipped host=none reason=no-tunnel-ingress
+# stderr, exit 1:  [brand-cache] STALE host=<h> path=<p> edge=<sha7> disk=<sha7> cf-cache-status=<s> age=<n>
+# stderr, exit 1:  [brand-cache] UNREACHABLE host=<h> path=<p> http=<code>
+#
+# No ingress hostname and no alias domain means no edge and therefore no
+# possible divergence, so that is a skip, not a pass — a caller must never read
+# the two as the same.
+#
+# Scope: the files under server/public/brand/ only. See the PATHS block below.
+#
+# BRAND_CACHE_CURL overrides the fetch command (tests stub it).
+set -uo pipefail
+
+INSTALL_DIR=""
+CONFIG_DIR=""
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --install-dir) INSTALL_DIR="$2"; shift 2 ;;
+    --config-dir) CONFIG_DIR="$2"; shift 2 ;;
+    *) echo "[brand-cache] unknown argument: $1" >&2; exit 2 ;;
+  esac
+done
+if [ -z "$INSTALL_DIR" ] || [ -z "$CONFIG_DIR" ]; then
+  echo "[brand-cache] usage: check-brand-cache.sh --install-dir <dir> --config-dir <dir>" >&2
+  exit 2
+fi
+
+CURL="${BRAND_CACHE_CURL:-curl}"
+
+# sha256sum is GNU; darwin ships shasum. Both print "<digest>  <path>".
+sha256() {
+  if command -v sha256sum >/dev/null 2>&1; then sha256sum "$1" | awk '{print $1}'
+  else shasum -a 256 "$1" | awk '{print $1}'; fi
+}
+
+# The hostname to probe, read from the same two sources and with the same
+# exclusions as platform/plugins/admin/mcp/src/lib/public-hostname.ts:
+# cloudflared/config.yml first, then alias-domains.json. First non-excluded
+# wins within each source.
+#
+# No apex tiebreak, and no attempt to pick the *public* host over the admin
+# one: only /brand/ assets are fetched, and the admin gate exempts /brand/ on
+# every host class (server/index.ts:1311-1322), so any ingress host serves them
+# identically. The alias source is read because an install whose edge is an
+# alias domain with no ingress row does have an edge that can diverge, and
+# reporting `skipped` there would read as nothing-to-check.
+resolve_host() {
+  local cfg="$CONFIG_DIR/cloudflared/config.yml" alias="$CONFIG_DIR/alias-domains.json" h
+  if [ -f "$cfg" ]; then
+    h="$(sed -n 's/^[[:space:]]*-[[:space:]]*hostname:[[:space:]]*\([^[:space:]]*\).*/\1/p' "$cfg" \
+      | grep -v '^localhost$' | grep -v '\.local$' | head -1)"
+    if [ -n "$h" ]; then echo "$h"; return 0; fi
+  fi
+  [ -f "$alias" ] || return 0
+  tr ',' '\n' < "$alias" | sed -n 's/.*"\([^"]*\)".*/\1/p' \
+    | grep -v '^localhost$' | grep -v '\.local$' | head -1
+}
+
+HOST="$(resolve_host)"
+if [ -z "$HOST" ]; then
+  echo "[brand-cache] skipped host=none reason=no-tunnel-ingress"
+  exit 0
+fi
+
+# /brand/ only. /brand-defaults.css is NOT exempt from the admin gate
+# (server/index.ts:1311-1322 lists /favicon.ico, /assets/, /brand/,
+# /api/calendar/free-busy and the PWA paths, and nothing else), so through an
+# admin-gated or operator host it answers with a login page at status 200
+# (index.ts:1379). Hashing that against the stylesheet on disk would be a
+# permanent STALE with no cache involved, which would both bury a real
+# divergence and make the clean line unreachable. Covering it, and the page
+# shells, needs a resolved public hostname — Task 2026.
+PUBLIC_DIR="$INSTALL_DIR/server/public"
+PATHS=()
+if [ -d "$PUBLIC_DIR/brand" ]; then
+  while IFS= read -r f; do PATHS+=("/brand/$(basename "$f")"); done \
+    < <(find "$PUBLIC_DIR/brand" -maxdepth 1 -type f | sort)
+fi
+
+# Nothing to compare is a skip with its own reason, not a clean run. Emitting
+# `files=0` here would read as a pass on an install whose payload never
+# deployed, and that is the dead signal the file count is pinned against.
+# Also the guard for bash 3.2 (darwin), where "${PATHS[@]}" on an empty array
+# is an unbound-variable error under `set -u`.
+if [ "${#PATHS[@]}" -eq 0 ]; then
+  echo "[brand-cache] skipped host=$HOST reason=no-brand-assets"
+  exit 0
+fi
+
+TMP="$(mktemp -d "${TMPDIR:-/tmp}/brand-cache.XXXXXX")"
+trap 'rm -rf "$TMP"' EXIT
+
+FAILED=0
+CHECKED=0
+for p in "${PATHS[@]}"; do
+  body="$TMP/body"; hdr="$TMP/hdr"
+  "$CURL" -sS -L -D "$hdr" -o "$body" "https://$HOST$p" >/dev/null 2>&1
+  code="$(awk 'tolower($0) ~ /^http\// {c=$2} END{print c+0}' "$hdr" 2>/dev/null)"
+  if [ "$code" != "200" ]; then
+    echo "[brand-cache] UNREACHABLE host=$HOST path=$p http=$code" >&2
+    FAILED=1
+    continue
+  fi
+  edge="$(sha256 "$body")"
+  disk="$(sha256 "$PUBLIC_DIR$p")"
+  if [ "$edge" != "$disk" ]; then
+    # tail -1, not head -1: -L means $hdr can hold several header blocks, and
+    # the cache state that matters is the one on the response the bytes came
+    # from. head -1 would name a redirect hop's cache state instead, which is
+    # the field an operator reads to tell this fault from an origin fault.
+    status="$(awk 'tolower($1) == "cf-cache-status:" {print $2}' "$hdr" | tr -d '\r' | tail -1)"
+    age="$(awk 'tolower($1) == "age:" {print $2}' "$hdr" | tr -d '\r' | tail -1)"
+    echo "[brand-cache] STALE host=$HOST path=$p edge=${edge:0:7} disk=${disk:0:7} cf-cache-status=${status:-none} age=${age:-0}" >&2
+    FAILED=1
+    continue
+  fi
+  CHECKED=$((CHECKED + 1))
+done
+
+[ "$FAILED" -eq 1 ] && exit 1
+echo "[brand-cache] clean host=$HOST files=$CHECKED"
+exit 0

package/payload/platform/scripts/check-risk-class.mjs

@@ -92,13 +92,18 @@ function collectPluginDirs() {
 }
 
 /** Independent of tool-surface.ts on purpose: a gate that shares the parser it
- *  is checking cannot detect that parser drifting. */
+ *  is checking cannot detect that parser drifting.
+ *
+ *  Task 1998 — `hidden:` entries carry the same name+riskClass shape as
+ *  `tools:` entries and are served by the same MCP server, so a hidden tool
+ *  can contradict its own name exactly as a visible one can. Scanning only
+ *  `tools:` would leave eight declarations outside the gate. */
 function declaredTools(manifestPath) {
   const out = []
   let current = null
   let inTools = false
   for (const line of readFileSync(manifestPath, 'utf8').split(/\r?\n/)) {
-    if (/^tools:\s*$/.test(line)) { inTools = true; continue }
+    if (/^(tools|hidden):\s*$/.test(line)) { inTools = true; current = null; continue }
     if (inTools && /^[A-Za-z_]/.test(line)) inTools = false
     if (!inTools) continue
     const name = line.match(/^\s+-\s+name:\s*(.+?)\s*$/)

package/payload/platform/scripts/check-specialist-tool-surface.mjs

@@ -88,8 +88,11 @@ function parsePluginManifest(rawManifest) {
       if (nameLine) { tools.push(nameLine[1]); continue; }
     }
     if (mode === 'hidden') {
-      const item = line.match(/^\s+-\s+(.+?)\s*$/);
-      if (item) hidden.push(item[1]);
+      // Task 1998 — hidden entries carry the same `- name:` + `riskClass:`
+      // shape as tools entries. Names only here; the gate checks membership
+      // of the `all` surface, not consequence.
+      const nameLine = line.match(/^\s+-\s+name:\s*(.+?)\s*$/);
+      if (nameLine) hidden.push(nameLine[1]);
     }
   }
   return { tools, hidden, hasTools };

package/payload/platform/scripts/lib/canonical-tool-names.mjs

@@ -36,9 +36,12 @@ function extractFrontmatter(md) {
   return md.slice(3, end)
 }
 
-// Collect `- name: <x>` entries under a bare `tools:` block and `- <x>` entries
-// under a bare `hidden:` block. Both contribute names a specialist may list in
-// its `tools:` frontmatter, so both belong to the live set.
+// Collect `- name: <x>` entries under a bare `tools:` block and under a bare
+// `hidden:` block. Both contribute names a specialist may list in its `tools:`
+// frontmatter, so both belong to the live set. Task 1998 gave the hidden block
+// the same name+riskClass shape as tools, so the two branches now read alike;
+// this parser stays separate from tool-surface.ts on purpose, so a drift in one
+// shows up as a diff rather than as agreement between a parser and itself.
 function parseToolNames(frontmatter) {
   const lines = frontmatter.split('\n')
   const names = []
@@ -57,7 +60,7 @@ function parseToolNames(frontmatter) {
       const m = line.match(/^\s+-\s+name:\s*(.+?)\s*$/)
       if (m) names.push(m[1])
     } else if (mode === 'hidden') {
-      const m = line.match(/^\s+-\s+(.+?)\s*$/)
+      const m = line.match(/^\s+-\s+name:\s*(.+?)\s*$/)
       if (m) names.push(m[1])
     }
   }

package/payload/platform/scripts/lib/provision-account-dir.sh

@@ -251,6 +251,49 @@ SETTINGS_EOF
     [ -f "$specialist" ] && cp "$specialist" "$ACCOUNT_DIR/specialists/agents/$(basename "$specialist")"
   done
 
+  # Task 1996 — the copy loop above re-delivers every core specialist, which
+  # would silently undo a disable on the next publish. specialists/agents/ is
+  # the dispatchable set (spawn-context.ts reads it), so an agent the operator
+  # switched off is removed again here. The quarantined copy under
+  # specialists/agents-disabled/ is never touched: it is the operator's own
+  # file, and for a premium or edited agent it is the only copy.
+  #
+  # An unreadable store withholds NOTHING. A corrupt file is not evidence that
+  # an agent was disabled, and withholding the whole set on a parse error would
+  # turn a bad byte into a fleet-wide loss of specialists.
+  if [ -f "$ACCOUNT_DIR/agents-disabled.json" ]; then
+    local _disabled_names _withheld=0
+    if _disabled_names="$(python3 -c '
+import json, sys
+with open(sys.argv[1]) as fh:
+    names = json.load(fh)["disabled"]
+if not isinstance(names, list):
+    raise SystemExit(1)
+for n in names:
+    if isinstance(n, str) and n.endswith(".md") and "/" not in n and ".." not in n:
+        print(n)
+' "$ACCOUNT_DIR/agents-disabled.json" 2>/dev/null)"; then
+      local _name
+      while IFS= read -r _name; do
+        [ -n "$_name" ] || continue
+        if [ -e "$ACCOUNT_DIR/specialists/agents/$_name" ]; then
+          # MOVE, never delete. In the drift state the standing parity check
+          # exists to catch (store names it, file is live, quarantine empty) a
+          # delete would destroy the only copy of a premium `--` agent or an
+          # operator-edited override: the replace loop above skips `*--*` and
+          # the copy loop only restores templates, so nothing re-delivers it.
+          mkdir -p "$ACCOUNT_DIR/specialists/agents-disabled"
+          mv -f "$ACCOUNT_DIR/specialists/agents/$_name" \
+                "$ACCOUNT_DIR/specialists/agents-disabled/$_name"
+          _withheld=$((_withheld + 1))
+        fi
+      done <<< "$_disabled_names"
+      echo "  specialists agents-withheld=$_withheld (disabled by operator)"
+    else
+      echo "  specialists agents-disabled-store-unreadable — withholding nothing"
+    fi
+  fi
+
   rm -f "$ACCOUNT_DIR/.claude/agents/"*.md 2>/dev/null || true
 
   # SOUL.md — user-controlled. Only create if missing. Never overwrite.

package/payload/platform/services/claude-session-manager/dist/account-dir-schema-reconcile.d.ts

@@ -15,7 +15,7 @@ export interface ReconcileResult extends ReconcileCounts {
 /** The single per-run summary line body. A non-zero count is the standing signal
  *  that an agent authored folders the hard guards could not prevent. Pure
  *  formatter so the emitter and its test share one wording. */
-export declare function formatReconcileLine(c: ReconcileCounts, homeMissing?: number, homeUnaudited?: number): string;
+export declare function formatReconcileLine(c: ReconcileCounts, homeMissing?: number, homeUnaudited?: number, agentDrift?: number): string;
 /** Parse the fenced ```allowed-top-level block from an account's SCHEMA.md —
  *  the same structured set fs-schema-guard.sh parses with awk. Returns the
  *  entry names (blank lines dropped). An absent block yields an empty set. */

package/payload/platform/services/claude-session-manager/dist/account-dir-schema-reconcile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"account-dir-schema-reconcile.d.ts","sourceRoot":"","sources":["../src/account-dir-schema-reconcile.ts"],"names":[],"mappings":"AAsFA,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAA;IACrB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD;;;;;0CAKsC;IACtC,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB;AAED;;+DAE+D;AAC/D,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,eAAe,EAAE,WAAW,SAAI,EAAE,aAAa,SAAI,GAAG,MAAM,CAGlG;AAED;;8EAE8E;AAC9E,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAcpE;AA+ED;;;8EAG8E;AAC9E,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAoCpE;AAED,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC/B;AAyBD;;;;;;;;;;;;;iCAaiC;AACjC,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CA+CtD;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,IAAI,IAAI,CAAA;IACb,IAAI,IAAI,IAAI,CAAA;CACb;AAED;oDACoD;AACpD,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,aAAa,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAC3C,yBAAyB,CAiB3B"}
+{"version":3,"file":"account-dir-schema-reconcile.d.ts","sourceRoot":"","sources":["../src/account-dir-schema-reconcile.ts"],"names":[],"mappings":"AA2FA,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAA;IACrB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD;;;;;0CAKsC;IACtC,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB;AAED;;+DAE+D;AAC/D,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,eAAe,EAClB,WAAW,SAAI,EACf,aAAa,SAAI,EACjB,UAAU,SAAI,GACb,MAAM,CAGR;AAED;;8EAE8E;AAC9E,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAcpE;AA+ED;;;8EAG8E;AAC9E,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAoCpE;AAED,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC/B;AA0DD;;;;;;;;;;;;;iCAaiC;AACjC,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CA8DtD;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,IAAI,IAAI,CAAA;IACb,IAAI,IAAI,IAAI,CAAA;CACb;AAED;oDACoD;AACpD,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,aAAa,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAC3C,yBAAyB,CAiB3B"}