@7365admin1/layer-common 4.123.0 → 4.124.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @iservice365/layer-common
 
+## 4.124.0
+
+### Minor Changes
+
+- 82bac6e: Robots: big red "Emergency stop" on robot detail for anyone who may command the robot (PadBot; one tap, no confirm, says which path reached the robot). Super Admin "Robot setup" section on robot detail: draw / rename / remove no-go areas, virtual walls and slow zones on the robot's real map (Ounitech; safe zones view only), cleaning schedules and timed switch on/off (add, edit, on/off, delete), robot / site / map names, save dock where the robot is charging, switch floor, named settings (speeds only lower), and PadBot saved points (add at the robot or on the map, move, rename, delete; charger locked). Every change has a one-sentence confirm and shows the maker's read-back.
+
+## 4.123.1
+
+### Patch Changes
+
+- 2a14035: Robots Setup: "Floors on the map" now names the robot that reports a floor the map lacks and lists the map's floors; a lift whose gateway exists but is not connected offers "Open lift queue" instead of "Connect gateway" (which would replace its code).
+
 ## 4.123.0
 
 ### Minor Changes
@@ -3252,11 +3264,11 @@ Monthly report: a month that had patrols opens the list of that month's patrol r
   `utils/console-tier.ts` + `composables/useConsoleTier.ts` mirror the server's
   own rule from two endpoints the console already calls, unprojected:
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                          GET /api/members/user/:user/app/admin    the Seven365 staff membership
-                                                                                                                                                                                                                                                                                                                                                                                                                                          GET /api/roles/id/:role                  that membership's role document
+                                                                                                                                                                                                                                                                                                                                                                                                                                              GET /api/members/user/:user/app/admin    the Seven365 staff membership
+                                                                                                                                                                                                                                                                                                                                                                                                                                              GET /api/roles/id/:role                  that membership's role document
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                          owner  = member.type === "admin" && role.type === "admin" && role.default === true
-                                                                                                                                                                                                                                                                                                                                                                                                                                          staff  = member.type === "admin" && role.type === "admin"
+                                                                                                                                                                                                                                                                                                                                                                                                                                              owner  = member.type === "admin" && role.type === "admin" && role.default === true
+                                                                                                                                                                                                                                                                                                                                                                                                                                              staff  = member.type === "admin" && role.type === "admin"
 
   `role.default` is the marker because it is the only property of a platform
   staff role no API caller can set - `role.controller.ts` validates create and

package/components/Robot/Detail.vue

@@ -30,6 +30,9 @@
     </div>
   </div>
 
+  <!-- Emergency stop: anyone allowed to command this robot, one tap, no confirm (PadBot today). -->
+  <RobotEmergencyStop v-if="cmdOk && caps?.emergencyStop === true" :robot-id="robotId" :name="record?.name" @stopped="fastUntil = Date.now() + COMMAND_FOLLOW_MS" />
+
   <div v-if="error" class="hero-notice" role="alert">{{ error }}</div>
   <div v-else-if="live && !live.ok && live.reason" class="hero-notice" role="status">Can't read this robot right now: {{ live.reason }}</div>
 
@@ -199,6 +202,9 @@
   <!-- Cleaning robots: recent jobs, alert history, every reading, parts wear, power schedule, lifts (read-only). -->
   <RobotCleaningRecords v-if="!noInterface && record && robotType !== 'security'" :robot-id="robotId" :maker-app="makerApp" :brand="brand" />
 
+  <!-- Seven365 Super Admin: change the robot's setup in its maker's cloud (zones, schedules, settings, points). -->
+  <RobotSetupPanel v-if="superAdmin && hasSetup" :robot-id="robotId" :name="record?.name" :brand="brand" :capabilities="caps" />
+
   <!-- What THIS robot (brand + model) can do, in our words; folded so it never pushes the camera down. -->
   <details v-if="abilities.length" class="hero-can hero-can--fold">
     <summary class="hero-can__title">What this robot can do</summary>
@@ -304,6 +310,8 @@ import RobotPatrolHistory from "./PatrolHistory.vue";
 import RobotLiveView from "./LiveView.vue";
 import RobotManualDrive from "./ManualDrive.vue";
 import RobotPointPicker from "./PointPicker.vue";
+import RobotEmergencyStop from "./EmergencyStop.vue";
+import RobotSetupPanel from "./SetupPanel.vue";
 import { faultPhotos } from "../../utils/robot-control";
 import { cleanAreaChoices, cleanAreaCommand, mapLayerLegend, robotMapDefault, robotMapViews } from "../../utils/robot-maps";
 import useRobotLive, { siteStatesFeed } from "../../composables/useRobotLive";
@@ -480,6 +488,8 @@ const abilities = computed(() =>
 const makerApp = computed(() => (live.value?.ok ? live.value.profile?.makerApp : "") || `${brand.value}'s own app`);
 
 const online = computed(() => live.value?.ok === true && live.value.online === true);
+// Setup sections this brand + model offers (Super Admin only; the server refuses anyone else).
+const hasSetup = computed(() => ["setupZones", "setupSchedules", "setupSettings", "setupPoints"].some((k) => caps.value?.[k] === true));
 const commands = computed(() =>
   visibleCommands({ capabilities: caps.value, canCommand: cmdOk.value, online: online.value, mode: statusMode.value, type: robotType.value, resumable: resumable.value }),
 );

package/components/Robot/EmergencyStop.vue

@@ -0,0 +1,91 @@
+<template>
+  <!--
+    Emergency stop (owner 2026-10-15): a big red button for anyone allowed to
+    command this robot. One tap, NO confirm - a stop must never wait on a
+    dialog or on a state read. The server sends PadBot's "full machine stop"
+    over the live link AND its stop command, and says which reached the robot.
+  -->
+  <div class="hero-estop" role="group" aria-label="Emergency stop">
+    <button type="button" class="hero-estop__btn" :disabled="busy" @click="stop">
+      <span class="hero-estop__icon" aria-hidden="true">■</span>
+      {{ busy ? "Stopping…" : "Emergency stop" }}
+    </button>
+    <div v-if="result" class="hero-estop__msg" :class="{ 'hero-estop__msg--error': failed }" role="status" aria-live="assertive">{{ result }}</div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref } from "vue";
+import { estopResultText } from "../../utils/robot-config";
+
+const props = defineProps<{ robotId: string; name?: string }>();
+const emit = defineEmits<{ stopped: [] }>();
+const { emergencyStopRobot } = useRobots();
+
+const busy = ref(false);
+const result = ref("");
+const failed = ref(false);
+
+async function stop() {
+  // A second press while the first is on its way is not lost: the server sends the stop again.
+  busy.value = true;
+  failed.value = false;
+  result.value = "";
+  try {
+    const r = await emergencyStopRobot(props.robotId);
+    result.value = `${estopResultText(r)}${r?.holdMinutes ? ` HERO Fleet Core can't move it for ${r.holdMinutes} minutes.` : ""}`;
+    emit("stopped");
+  } catch (e: any) {
+    failed.value = true;
+    result.value = e?.data?.message || e?.message || `The emergency stop did not reach ${props.name || "the robot"}. Press the red button on the robot.`;
+  } finally {
+    busy.value = false;
+  }
+}
+</script>
+
+<style scoped>
+.hero-estop {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px 12px;
+  margin: 8px 0;
+}
+.hero-estop__btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 10px;
+  min-height: 52px;
+  padding: 0 24px;
+  border: 2px solid #7f1d1d;
+  border-radius: 10px;
+  background: #dc2626;
+  color: #fff;
+  font-size: 1.05rem;
+  font-weight: 700;
+  letter-spacing: 0.02em;
+  cursor: pointer;
+}
+.hero-estop__btn:hover:not(:disabled) {
+  background: #b91c1c;
+}
+.hero-estop__btn:focus-visible {
+  outline: 3px solid #fca5a5;
+  outline-offset: 2px;
+}
+.hero-estop__btn:disabled {
+  opacity: 0.75;
+  cursor: progress;
+}
+.hero-estop__icon {
+  font-size: 0.9rem;
+}
+.hero-estop__msg {
+  font-size: 0.9rem;
+}
+.hero-estop__msg--error {
+  color: #b91c1c;
+  font-weight: 600;
+}
+</style>

package/components/Robot/SetupPanel.vue

@@ -0,0 +1,302 @@
+<template>
+  <!--
+    Robot setup - Seven365 Super Admin only (owner rule 12 Oct 2026; the server
+    refuses anyone else). Everything here changes the robot in its maker's
+    cloud: one change at a time, a one-sentence confirm, sent once, then READ
+    BACK from the maker so what shows is the robot's own copy. Sections appear
+    only for what this brand + model can do (hide, never grey).
+  -->
+  <details class="hero-can hero-can--fold hero-setup" :open="open" @toggle="onToggle">
+    <summary class="hero-can__title">Robot setup · Seven365 Super Admin</summary>
+    <p class="hero-muted">Changes go straight to the robot's own cloud ({{ brandLabel }}) and are read back from it. Clients never see this section.</p>
+
+    <div v-if="loading && !setup" class="hero-sched__empty">Reading the robot's setup from {{ brandLabel }}…</div>
+    <div v-if="loadError" class="hero-notice hero-notice--error" role="alert">{{ loadError }}</div>
+    <div v-if="result" class="hero-notice" :class="{ 'hero-notice--error': result.error }" role="status" aria-live="polite">{{ result.text }}</div>
+
+    <template v-if="setup">
+      <!-- Zones: virtual walls / no-go areas, slow zones (Ounitech) -->
+      <section v-if="caps.setupZones === true" class="hero-setup__section" aria-label="Walls and zones">
+        <div class="hero-section__title">No-go areas, virtual walls and slow zones</div>
+        <RobotSetupZones :setup="setup" :busy="busy" :robot-name="name" @map="loadMap" @apply="ask" />
+      </section>
+
+      <!-- Saved target points (PadBot) -->
+      <section v-if="caps.setupPoints === true" class="hero-setup__section" aria-label="Saved points">
+        <div class="hero-section__title">Saved points (patrol and go-to points)</div>
+        <RobotSetupPoints :setup="setup" :busy="busy" @apply="ask" />
+      </section>
+
+      <!-- Cleaning schedules + timed switch on / off (Ounitech) -->
+      <section v-if="caps.setupSchedules === true" class="hero-setup__section" aria-label="Schedules">
+        <div class="hero-section__title">Cleaning schedules</div>
+        <p class="hero-muted">Times are the robot's local time (Singapore, UTC+8). Schedules run only while "Schedules switched on" is On under Settings.</p>
+        <div v-if="setup.plans?.error" class="hero-notice hero-notice--error">{{ setup.plans.error }}</div>
+        <div v-else-if="!plans.length" class="hero-sched__empty">No cleaning schedules on the robot.</div>
+        <div v-for="p in plans" :key="p.planId" class="hero-sched__row hero-setup__row">
+          <b>{{ daysText(p.days) }}</b>
+          <span>{{ p.startTime }}-{{ p.endTime }} · {{ p.times }} pass{{ p.times === 1 ? "" : "es" }} · {{ p.floors.length ? `floor ${p.floors.join(", ")}` : "floor not set" }}{{ p.wholeFloor ? "" : " · areas set in the Ounitech app" }}</span>
+          <span class="hero-setup__actions">
+            <v-btn size="small" variant="outlined" :disabled="busy" @click="ask({ action: 'plan-enable', planIds: [p.planId], enabled: !p.enabled })">{{ p.enabled ? "On · switch off" : "Off · switch on" }}</v-btn>
+            <v-btn size="small" variant="text" :disabled="busy" @click="editPlan(p)">Edit</v-btn>
+            <v-btn size="small" variant="text" :disabled="busy" @click="ask({ action: 'plan-delete', planIds: [p.planId] })">Delete</v-btn>
+          </span>
+        </div>
+        <div class="hero-setup__form">
+          <div class="hero-setup__formtitle">{{ planForm.planId ? "Edit schedule" : "Add a schedule (whole floor, vacuum)" }}</div>
+          <label v-if="!planForm.planId">Floor
+            <select v-model.number="planForm.floorNo" class="hero-input hero-select hero-select--sm">
+              <option v-for="f in setup.floors ?? []" :key="f" :value="f">{{ f }}</option>
+            </select>
+          </label>
+          <label>Start <input v-model="planForm.startTime" type="time" class="hero-input" /></label>
+          <label>End <input v-model="planForm.endTime" type="time" class="hero-input" /></label>
+          <label>Passes <input v-model.number="planForm.times" type="number" min="1" max="99" class="hero-input hero-setup__num" /></label>
+          <span class="hero-setup__days">
+            <label v-for="d in DAY_CHOICES" :key="d.value"><input v-model="planForm.days" type="checkbox" :value="d.value" /> {{ d.title }}</label>
+          </span>
+          <label><input v-model="planForm.enabled" type="checkbox" /> Switched on</label>
+          <div v-if="planProblem" class="hero-muted">{{ planProblem }}</div>
+          <span class="hero-setup__actions">
+            <v-btn size="small" color="primary" variant="flat" :disabled="busy || !!planProblem || (!planForm.planId && planForm.floorNo == null)" @click="savePlan">Save schedule</v-btn>
+            <v-btn v-if="planForm.planId" size="small" variant="text" @click="resetPlan">Cancel edit</v-btn>
+          </span>
+        </div>
+
+        <div class="hero-section__title">Timed switch on / off</div>
+        <div v-if="setup.power?.error" class="hero-notice hero-notice--error">{{ setup.power.error }}</div>
+        <div v-else-if="!power.length" class="hero-sched__empty">No timed switch on / off on the robot.</div>
+        <div v-for="p in power" :key="p.planId" class="hero-sched__row hero-setup__row">
+          <b>{{ daysText(p.days) }}</b>
+          <span>Switch {{ p.action }} at {{ p.time }}</span>
+          <span class="hero-setup__actions">
+            <v-btn size="small" variant="outlined" :disabled="busy" @click="ask({ action: 'power-enable', planIds: [p.planId], enabled: !p.enabled })">{{ p.enabled ? "On · switch off" : "Off · switch on" }}</v-btn>
+            <v-btn size="small" variant="text" :disabled="busy" @click="editPower(p)">Edit</v-btn>
+            <v-btn size="small" variant="text" :disabled="busy" @click="ask({ action: 'power-delete', planIds: [p.planId] })">Delete</v-btn>
+          </span>
+        </div>
+        <div class="hero-setup__form">
+          <div class="hero-setup__formtitle">{{ powerForm.planId ? "Edit timed switch" : "Add a timed switch" }}</div>
+          <label>Switch
+            <select v-model="powerForm.switchTo" class="hero-input hero-select hero-select--sm">
+              <option value="off">off</option>
+              <option value="on">on</option>
+            </select>
+          </label>
+          <label>at <input v-model="powerForm.time" type="time" class="hero-input" /></label>
+          <span class="hero-setup__days">
+            <label v-for="d in DAY_CHOICES" :key="d.value"><input v-model="powerForm.days" type="checkbox" :value="d.value" /> {{ d.title }}</label>
+          </span>
+          <label><input v-model="powerForm.enabled" type="checkbox" /> Switched on</label>
+          <span class="hero-setup__actions">
+            <v-btn size="small" color="primary" variant="flat" :disabled="busy || !/^\d\d:\d\d$/.test(powerForm.time) || !powerForm.days.length" @click="savePower">Save</v-btn>
+            <v-btn v-if="powerForm.planId" size="small" variant="text" @click="resetPower">Cancel edit</v-btn>
+          </span>
+        </div>
+      </section>
+
+      <!-- Names, dock, floor, settings (Ounitech) -->
+      <section v-if="caps.setupSettings === true" class="hero-setup__section" aria-label="Robot settings">
+        <div class="hero-section__title">Names, dock and floor</div>
+        <div class="hero-setup__form">
+          <label>Name in the Ounitech app <input v-model="names.robot" class="hero-input" maxlength="40" /></label>
+          <v-btn size="small" variant="outlined" :disabled="busy || !names.robot.trim() || names.robot.trim() === setup.robotName" @click="ask({ action: 'robot-name', name: names.robot.trim() })">Rename robot</v-btn>
+        </div>
+        <div class="hero-setup__form">
+          <label>Ounitech site name <input v-model="names.scene" class="hero-input" maxlength="40" /></label>
+          <v-btn size="small" variant="outlined" :disabled="busy || !names.scene.trim() || names.scene.trim() === setup.sceneName" @click="ask({ action: 'scene-name', name: names.scene.trim() })">Rename site</v-btn>
+        </div>
+        <div v-if="currentMap" class="hero-setup__form">
+          <label>Name of map shown ({{ currentMap.name }}) <input v-model="names.map" class="hero-input" maxlength="40" /></label>
+          <v-btn size="small" variant="outlined" :disabled="busy || !names.map.trim() || names.map.trim() === currentMap.name" @click="ask({ action: 'map-name', mapId: currentMap.mapId, name: names.map.trim() }, { map: currentMap.name })">Rename map</v-btn>
+        </div>
+        <div class="hero-setup__form">
+          <span>Dock: {{ setup.docked ? "the robot is on its dock and charging now." : "push the robot onto its dock (it must show Charging) to save the dock from here." }}</span>
+          <v-btn size="small" variant="outlined" :disabled="busy || !setup.docked" @click="ask({ action: 'dock-here' })">Save dock where the robot is</v-btn>
+        </div>
+        <div v-if="(setup.floors ?? []).length > 1" class="hero-setup__form">
+          <span>Floor now: {{ setup.floorNo ?? "not reported" }}. Switch only after the robot has been taken to the other floor.</span>
+          <select v-model.number="floorTo" class="hero-input hero-select hero-select--sm" aria-label="Floor">
+            <option v-for="f in setup.floors" :key="f" :value="f">{{ f }}</option>
+          </select>
+          <v-btn size="small" variant="outlined" :disabled="busy || setup.working || floorTo == null || floorTo === setup.floorNo" @click="ask({ action: 'switch-floor', floorNo: floorTo })">Switch floor</v-btn>
+        </div>
+
+        <div class="hero-section__title">Settings</div>
+        <p class="hero-muted">Only settings we can name are listed. Safety sensors, the time zone and Wi-Fi stay in the Ounitech app. Speeds can only be lowered here.</p>
+        <div v-if="setup.settings?.error" class="hero-notice hero-notice--error">{{ setup.settings.error }}</div>
+        <div v-for="s in settings" :key="s.key" class="hero-sched__row hero-setup__row">
+          <b>{{ s.label }}</b>
+          <span v-if="s.kind === 'bool'"><label><input v-model="edited[s.key]" type="checkbox" /> {{ edited[s.key] ? "On" : "Off" }}</label></span>
+          <span v-else>
+            <input v-model.number="edited[s.key]" type="number" :min="s.min" :max="s.max" :step="s.kind === 'int' ? 1 : 0.05" class="hero-input hero-setup__num" :aria-label="s.label" />
+            {{ s.unit }} <span class="hero-muted">({{ s.min }}-{{ s.max }})</span>
+          </span>
+        </div>
+        <v-btn v-if="settings.length" size="small" color="primary" variant="flat" :disabled="busy || !Object.keys(changedSettings).length" @click="ask({ action: 'settings', values: changedSettings })">Save settings</v-btn>
+      </section>
+    </template>
+
+    <v-dialog v-model="confirmOpen" width="460">
+      <div v-if="confirming" class="hero-dialog" role="alertdialog" aria-labelledby="hero-setup-confirm">
+        <div id="hero-setup-confirm" class="hero-dialog__title">{{ confirming.text.title }}</div>
+        <div class="hero-dialog__body">{{ confirming.text.body }}</div>
+        <div class="hero-dialog__actions">
+          <v-btn variant="outlined" @click="confirmOpen = false">Don't change</v-btn>
+          <v-btn color="primary" variant="flat" :loading="busy" @click="send">{{ confirming.text.action }}</v-btn>
+        </div>
+      </div>
+    </v-dialog>
+  </details>
+</template>
+
+<script setup lang="ts">
+import { computed, reactive, ref, watch } from "vue";
+import RobotSetupZones from "./SetupZones.vue";
+import RobotSetupPoints from "./SetupPoints.vue";
+import { DAY_CHOICES, daysText, scheduleProblem, settingsDiff, setupConfirmText } from "../../utils/robot-config";
+
+const props = defineProps<{ robotId: string; name?: string; brand?: string; capabilities?: Record<string, unknown> | null }>();
+const emit = defineEmits<{ changed: [] }>();
+const { getRobotSetup, applyRobotSetup } = useRobots();
+
+const caps = computed(() => props.capabilities ?? {});
+const brandLabel = computed(() => props.brand || "the maker");
+const open = ref(false);
+const setup = ref<Record<string, any> | null>(null);
+const loading = ref(false);
+const loadError = ref("");
+const busy = ref(false);
+const result = ref<{ text: string; error: boolean } | null>(null);
+const mapId = ref<string | null>(null);
+
+const errText = (e: any, fallback: string) => e?.data?.message || e?.message || fallback;
+
+async function load() {
+  loading.value = true;
+  loadError.value = "";
+  try {
+    setup.value = await getRobotSetup(props.robotId, mapId.value);
+    mapId.value = setup.value?.mapId ?? setup.value?.currentMapId ?? mapId.value;
+  } catch (e: any) {
+    loadError.value = errText(e, "Couldn't read the robot's setup from its cloud.");
+  } finally {
+    loading.value = false;
+  }
+}
+function onToggle(e: Event) {
+  open.value = (e.target as HTMLDetailsElement).open;
+  if (open.value && !setup.value && !loading.value) void load();
+}
+function loadMap(id: string) {
+  mapId.value = id;
+  void load();
+}
+
+/* ---- confirm -> send once -> read back ---- */
+const confirmOpen = ref(false);
+const confirming = ref<{ change: Record<string, any>; text: ReturnType<typeof setupConfirmText> } | null>(null);
+const currentMap = computed(() => (setup.value?.maps ?? []).find((m: any) => m.mapId === (setup.value?.mapId ?? mapId.value)) ?? null);
+
+function ask(change: Record<string, any>, ctx: { map?: string } = {}) {
+  confirming.value = { change, text: setupConfirmText(change, { robot: props.name, map: ctx.map ?? currentMap.value?.name }) };
+  confirmOpen.value = true;
+}
+async function send() {
+  if (!confirming.value || busy.value) return;
+  busy.value = true;
+  result.value = null;
+  try {
+    const r = await applyRobotSetup(props.robotId, confirming.value.change);
+    result.value = { text: `${r.summary}. Read back from the robot's cloud.`, error: false };
+    confirmOpen.value = false;
+    resetPlan();
+    resetPower();
+    await load();
+    emit("changed");
+  } catch (e: any) {
+    result.value = { text: `Not changed: ${errText(e, "the robot's cloud refused it.")}`, error: true };
+    confirmOpen.value = false;
+  } finally {
+    busy.value = false;
+  }
+}
+
+/* ---- schedules ---- */
+const plans = computed<any[]>(() => setup.value?.plans?.value ?? []);
+const power = computed<any[]>(() => setup.value?.power?.value ?? []);
+const blankPlan = () => ({ planId: 0, floorNo: (setup.value?.floorNo ?? setup.value?.floors?.[0] ?? null) as number | null, startTime: "08:00", endTime: "10:00", days: [1, 2, 3, 4, 5] as number[], times: 1, enabled: true });
+const planForm = reactive(blankPlan());
+const planProblem = computed(() => scheduleProblem(planForm.startTime, planForm.endTime, planForm.days));
+function resetPlan() {
+  Object.assign(planForm, blankPlan());
+}
+function editPlan(p: any) {
+  Object.assign(planForm, { planId: p.planId, floorNo: p.floors?.[0] ?? null, startTime: p.startTime, endTime: p.endTime, days: [...p.days], times: p.times, enabled: p.enabled });
+}
+function savePlan() {
+  const { planId, floorNo, ...rest } = planForm;
+  ask({ action: "plan-save", ...(planId ? { planId } : { floorNo }), ...rest, days: [...rest.days] });
+}
+const blankPower = () => ({ planId: 0, switchTo: "off" as "on" | "off", time: "20:00", days: [1, 2, 3, 4, 5] as number[], enabled: true });
+const powerForm = reactive(blankPower());
+function resetPower() {
+  Object.assign(powerForm, blankPower());
+}
+function editPower(p: any) {
+  Object.assign(powerForm, { planId: p.planId, switchTo: p.action, time: p.time, days: [...p.days], enabled: p.enabled });
+}
+function savePower() {
+  const { planId, ...rest } = powerForm;
+  ask({ action: "power-save", ...(planId ? { planId } : {}), ...rest, days: [...rest.days] });
+}
+
+/* ---- names, floor, settings ---- */
+const names = reactive({ robot: "", scene: "", map: "" });
+const floorTo = ref<number | null>(null);
+const settings = computed<any[]>(() => setup.value?.settings?.value ?? []);
+const edited = reactive<Record<string, any>>({});
+watch(setup, (s) => {
+  names.robot = s?.robotName ?? "";
+  names.scene = s?.sceneName ?? "";
+  names.map = currentMap.value?.name ?? "";
+  floorTo.value = s?.floorNo ?? null;
+  for (const k of Object.keys(edited)) delete edited[k];
+  for (const x of s?.settings?.value ?? []) edited[x.key] = x.value;
+  if (!planForm.planId && planForm.floorNo == null) planForm.floorNo = s?.floorNo ?? s?.floors?.[0] ?? null;
+});
+const changedSettings = computed(() => settingsDiff(settings.value, edited));
+</script>
+
+<style>
+.hero-setup__section {
+  margin-top: 16px;
+}
+.hero-setup__row {
+  align-items: center;
+}
+.hero-setup__actions {
+  display: inline-flex;
+  flex-wrap: wrap;
+  gap: 4px;
+}
+.hero-setup__form {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px 12px;
+  margin: 8px 0;
+}
+.hero-setup__formtitle {
+  width: 100%;
+  font-weight: 600;
+}
+.hero-setup__days {
+  display: inline-flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+.hero-setup__num {
+  width: 90px;
+}
+</style>

package/components/Robot/SetupPoints.vue

@@ -0,0 +1,109 @@
+<template>
+  <!--
+    PadBot saved target points (§5.2-5.4) without the PadBot app: add one where
+    the robot stands now (the surest way) or where you click on the map, move,
+    rename, delete. The charging point is locked (set in the PadBot app). Every
+    change is confirmed, sent once and read back from PadBot.
+  -->
+  <div>
+    <div v-if="(setup.maps ?? []).length > 1" class="hero-mapsel">
+      <select v-model="mapId" class="hero-input hero-select hero-select--sm" aria-label="Robot map">
+        <option v-for="m in setup.maps" :key="m.mapId" :value="m.mapId">{{ m.name }}{{ m.mapId === setup.currentMapId ? " · Robot is here" : "" }}</option>
+      </select>
+    </div>
+    <div v-if="!map" class="hero-sched__empty">PadBot sent no maps for this robot.</div>
+    <template v-else>
+      <RobotLivePlan
+        v-if="map.imageUrl"
+        :image="map.imageUrl"
+        :aspect="map.width && map.height ? map.width / map.height : null"
+        :points="placed"
+        :spot="picked ? [picked] : []"
+        :pick="picking !== null"
+        @pick="(p) => (picked = p)"
+      />
+      <div v-if="picking" class="hero-spotbar" role="group" aria-label="Pick a spot">
+        <span>{{ picking === "add" ? "Click the map where the new point goes." : `Click the map where "${moving?.name}" goes.` }}</span>
+        <v-btn size="small" color="primary" variant="flat" :disabled="!picked || busy" @click="donePick">Use this spot</v-btn>
+        <v-btn size="small" variant="text" @click="stopPick">Cancel</v-btn>
+      </div>
+
+      <div v-if="!map.points.length" class="hero-sched__empty">No saved points on this map.</div>
+      <div v-for="p in map.points" :key="p.targetPointId" class="hero-sched__row">
+        <template v-if="p.locked">
+          <b>{{ p.name }}</b><span>Charging point · set in the PadBot app</span>
+        </template>
+        <template v-else>
+          <input v-model="names[p.targetPointId]" class="hero-input" maxlength="40" :aria-label="`Name of ${p.name}`" />
+          <span>{{ where(p) }}</span>
+          <span class="hero-setup__actions">
+            <v-btn size="small" variant="text" :disabled="busy || !names[p.targetPointId]?.trim() || names[p.targetPointId]?.trim() === p.name" @click="emit('apply', { action: 'point-update', mapId: map.mapId, targetPointId: p.targetPointId, name: names[p.targetPointId]!.trim() })">Rename</v-btn>
+            <v-btn size="small" variant="text" :disabled="busy || !map.imageUrl" @click="startPick('move', p)">Move</v-btn>
+            <v-btn size="small" variant="text" :disabled="busy || map.mapId !== setup.currentMapId" :title="map.mapId !== setup.currentMapId ? 'The robot is on another map' : ''" @click="emit('apply', { action: 'point-update', mapId: map.mapId, targetPointId: p.targetPointId, at: 'robot' })">Move to robot</v-btn>
+            <v-btn size="small" variant="text" :disabled="busy" @click="emit('apply', { action: 'point-delete', mapId: map.mapId, targetPointId: p.targetPointId })">Delete</v-btn>
+          </span>
+        </template>
+      </div>
+
+      <div class="hero-setup__form">
+        <div class="hero-setup__formtitle">Add a point</div>
+        <input v-model="newName" class="hero-input" maxlength="40" placeholder="Point name (e.g. P5 Lobby)" aria-label="New point name" />
+        <label>Facing (degrees, optional) <input v-model="newYaw" type="number" min="-180" max="180" class="hero-input hero-setup__num" /></label>
+        <v-btn size="small" color="primary" variant="flat" :disabled="busy || !newName.trim() || map.mapId !== setup.currentMapId" @click="add('robot')">Add where the robot is now</v-btn>
+        <v-btn size="small" variant="outlined" :disabled="busy || !newName.trim() || !map.imageUrl" @click="startPick('add')">Pick on the map</v-btn>
+      </div>
+    </template>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, reactive, ref, watch } from "vue";
+import RobotLivePlan from "./LivePlan.vue";
+import type { TShare } from "../../utils/robot-config";
+
+const props = defineProps<{ setup: Record<string, any>; busy?: boolean }>();
+const emit = defineEmits<{ apply: [change: Record<string, any>, ctx?: { map?: string }] }>();
+
+const mapId = ref<string | null>(null);
+watch(() => props.setup, (s) => {
+  if (!mapId.value || !(s.maps ?? []).some((m: any) => m.mapId === mapId.value)) mapId.value = s.currentMapId ?? s.maps?.[0]?.mapId ?? null;
+  for (const k of Object.keys(names)) delete names[k];
+  for (const m of s.maps ?? []) for (const p of m.points ?? []) names[p.targetPointId] = p.name;
+  newName.value = "";
+  stopPick();
+}, { immediate: true });
+const map = computed(() => (props.setup.maps ?? []).find((m: any) => m.mapId === mapId.value) ?? null);
+const placed = computed(() => (map.value?.points ?? []).filter((p: any) => p.at).map((p: any) => ({ targetPointId: p.targetPointId, name: p.name, x: p.at.x, y: p.at.y })));
+const names = reactive<Record<string, string>>({});
+const newName = ref("");
+const newYaw = ref<string | number>("");
+const where = (p: any) => (p.worldX != null && p.worldY != null ? `x ${p.worldX.toFixed(2)} m · y ${p.worldY.toFixed(2)} m${p.yaw != null ? ` · ${p.yaw}°` : ""}` : "position not given");
+
+const picking = ref<"add" | "move" | null>(null);
+const moving = ref<any>(null);
+const picked = ref<TShare | null>(null);
+function startPick(kind: "add" | "move", p: any = null) {
+  picking.value = kind;
+  moving.value = p;
+  picked.value = null;
+}
+function stopPick() {
+  picking.value = null;
+  moving.value = null;
+  picked.value = null;
+}
+const yaw = () => {
+  const n = Number(newYaw.value);
+  return newYaw.value === "" || !Number.isFinite(n) ? {} : { yaw: Math.max(-180, Math.min(180, Math.round(n))) };
+};
+function add(at: "robot" | TShare) {
+  if (!map.value) return;
+  emit("apply", { action: "point-add", mapId: map.value.mapId, name: newName.value.trim(), at, ...yaw() }, { map: map.value.name });
+}
+function donePick() {
+  if (!picked.value || !map.value) return;
+  const at = { x: Math.round(picked.value.x * 100) / 100, y: Math.round(picked.value.y * 100) / 100 };
+  if (picking.value === "add") add(at);
+  else if (moving.value) emit("apply", { action: "point-update", mapId: map.value.mapId, targetPointId: moving.value.targetPointId, at }, { map: map.value.name });
+}
+</script>

package/components/Robot/SetupZones.vue

@@ -0,0 +1,152 @@
+<template>
+  <!--
+    Draw on the robot's real map picture: a no-go area (a closed virtual wall -
+    the Ounitech manual's way to keep the robot out of a place), a wall line,
+    or a slow zone. Click to add corners. Saved per kind as the robot's FULL
+    list (its save replaces the list), refused if the list changed in the
+    Ounitech app meanwhile, then read back. Safe zones are shown, not edited:
+    inside one the robot IGNORES obstacles from its mapping run, so a wrong one
+    is a collision risk - they stay with the Ounitech engineer.
+  -->
+  <div>
+    <div v-if="(setup.maps ?? []).length > 1" class="hero-mapsel">
+      <select :value="map?.mapId" class="hero-input hero-select hero-select--sm" aria-label="Robot map" :disabled="dirty" @change="emit('map', ($event.target as HTMLSelectElement).value)">
+        <option v-for="m in setup.maps" :key="m.mapId" :value="m.mapId">{{ m.name }}{{ m.floorNo != null ? ` · floor ${m.floorNo}` : "" }}{{ m.current ? " · Robot is here" : "" }}</option>
+      </select>
+      <span v-if="dirty" class="hero-muted">Save or discard first to change map.</span>
+    </div>
+    <div v-for="e in errors" :key="e" class="hero-notice hero-notice--error">{{ e }}</div>
+    <div v-if="!map?.imageUrl" class="hero-sched__empty">Ounitech sent no picture for this map, so nothing can be drawn on it.</div>
+    <template v-else>
+      <RobotLivePlan
+        :name="robotName"
+        :image="map.imageUrl"
+        :aspect="map.width && map.height ? map.width / map.height : null"
+        :zones="drawn"
+        :spot="corners"
+        :pick="drawing !== null"
+        @pick="(p) => corners.push(p)"
+      />
+      <p class="hero-muted">Red lines = virtual walls and no-go areas · amber = slow zones · green = safe zones (view only). Positions use the robot's own map frame; check a drawing lines up with the picture's walls before saving.</p>
+
+      <div v-if="drawing" class="hero-spotbar" role="group" aria-label="Drawing">
+        <span>{{ DRAW_WORDS[drawing.kind] }}: click the map to add corners ({{ corners.length }} so far).</span>
+        <input v-model="drawing.name" class="hero-input" maxlength="40" placeholder="Name" aria-label="Name" />
+        <v-btn size="small" color="primary" variant="flat" :disabled="corners.length < minCorners || !drawing.name.trim()" @click="finish">Done</v-btn>
+        <v-btn size="small" variant="outlined" :disabled="!corners.length" @click="corners.pop()">Undo corner</v-btn>
+        <v-btn size="small" variant="text" @click="cancelDraw">Cancel</v-btn>
+      </div>
+      <div v-else class="hero-setup__form">
+        <v-btn size="small" variant="outlined" :disabled="busy" @click="startDraw('nogo')">Draw no-go area</v-btn>
+        <v-btn size="small" variant="outlined" :disabled="busy" @click="startDraw('line')">Draw wall line</v-btn>
+        <v-btn size="small" variant="outlined" :disabled="busy" @click="startDraw('slow')">Draw slow zone</v-btn>
+        <v-btn size="small" variant="text" :disabled="busy || dirty" @click="emit('apply', { action: 'auto-walls' })">Draw walls automatically</v-btn>
+      </div>
+
+      <div class="hero-setup__formtitle">Virtual walls and no-go areas</div>
+      <div v-if="!walls.length" class="hero-sched__empty">None on this map.</div>
+      <div v-for="(w, i) in walls" :key="`w${i}`" class="hero-sched__row">
+        <input v-model="w.name" class="hero-input" maxlength="40" :aria-label="`Name of wall ${i + 1}`" @input="wallsDirty = true" />
+        <span>{{ w.closed ? "No-go area" : "Wall line" }}{{ w.points ? " · redrawn" : "" }}{{ w.id ? "" : " · new" }}</span>
+        <span class="hero-setup__actions">
+          <v-btn size="small" variant="text" :disabled="busy || !!drawing" @click="startDraw(w.closed ? 'nogo' : 'line', w)">Redraw</v-btn>
+          <v-btn size="small" variant="text" :disabled="busy" @click="walls.splice(i, 1); wallsDirty = true">Remove</v-btn>
+        </span>
+      </div>
+      <div class="hero-setup__form">
+        <v-btn size="small" color="primary" variant="flat" :disabled="busy || !wallsDirty || !!drawing" @click="save('wall')">Save walls to robot</v-btn>
+      </div>
+
+      <div class="hero-setup__formtitle">Slow zones</div>
+      <div v-if="!slow.length" class="hero-sched__empty">None on this map.</div>
+      <div v-for="(z, i) in slow" :key="`s${i}`" class="hero-sched__row">
+        <input v-model="z.name" class="hero-input" maxlength="40" :aria-label="`Name of slow zone ${i + 1}`" @input="slowDirty = true" />
+        <span>Slow zone{{ z.points ? " · redrawn" : "" }}{{ z.id ? "" : " · new" }}</span>
+        <span class="hero-setup__actions">
+          <v-btn size="small" variant="text" :disabled="busy || !!drawing" @click="startDraw('slow', z)">Redraw</v-btn>
+          <v-btn size="small" variant="text" :disabled="busy" @click="slow.splice(i, 1); slowDirty = true">Remove</v-btn>
+        </span>
+      </div>
+      <div class="hero-setup__form">
+        <v-btn size="small" color="primary" variant="flat" :disabled="busy || !slowDirty || !!drawing" @click="save('slow')">Save slow zones to robot</v-btn>
+        <v-btn v-if="dirty" size="small" variant="text" :disabled="busy" @click="reset">Discard changes</v-btn>
+      </div>
+
+      <div class="hero-setup__formtitle">Safe zones (view only)</div>
+      <p class="hero-muted">Inside a safe zone the robot ignores obstacles recorded while mapping. They are set by the Ounitech engineer in the Ounitech app.</p>
+      <div v-for="(z, i) in safe" :key="`z${i}`" class="hero-sched__row"><span>{{ z.name || `Safe zone ${i + 1}` }}</span></div>
+    </template>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import RobotLivePlan from "./LivePlan.vue";
+import { draftsFrom, zonesChange, type TDraftShape, type TSetupShape, type TShare } from "../../utils/robot-config";
+
+const props = defineProps<{ setup: Record<string, any>; busy?: boolean; robotName?: string }>();
+const emit = defineEmits<{ map: [mapId: string]; apply: [change: Record<string, any>, ctx?: { map?: string }] }>();
+
+const DRAW_WORDS = { nogo: "No-go area", line: "Wall line", slow: "Slow zone" } as const;
+type TKind = keyof typeof DRAW_WORDS;
+
+const map = computed(() => (props.setup.maps ?? []).find((m: any) => m.mapId === props.setup.mapId) ?? null);
+const loadedWalls = computed<TSetupShape[]>(() => props.setup.zones?.walls?.value ?? []);
+const loadedSlow = computed<TSetupShape[]>(() => props.setup.zones?.slow?.value ?? []);
+const safe = computed<TSetupShape[]>(() => props.setup.zones?.safe?.value ?? []);
+const errors = computed(() =>
+  (["walls", "slow", "safe"] as const).map((k) => props.setup.zones?.[k]?.error).filter((e): e is string => !!e),
+);
+
+const walls = ref<TDraftShape[]>([]);
+const slow = ref<TDraftShape[]>([]);
+const wallsDirty = ref(false);
+const slowDirty = ref(false);
+const dirty = computed(() => wallsDirty.value || slowDirty.value);
+function reset() {
+  walls.value = draftsFrom(loadedWalls.value);
+  slow.value = draftsFrom(loadedSlow.value);
+  wallsDirty.value = slowDirty.value = false;
+  cancelDraw();
+}
+watch(() => props.setup, reset, { immediate: true });
+
+/* ---- drawing ---- */
+const drawing = ref<{ kind: TKind; name: string; target: TDraftShape | null } | null>(null);
+const corners = ref<TShare[]>([]);
+const minCorners = computed(() => (drawing.value?.kind === "line" ? 2 : 3));
+function startDraw(kind: TKind, target: TDraftShape | null = null) {
+  drawing.value = { kind, name: target?.name ?? "", target };
+  corners.value = [];
+}
+function cancelDraw() {
+  drawing.value = null;
+  corners.value = [];
+}
+function finish() {
+  const d = drawing.value;
+  if (!d) return;
+  const pts = corners.value.slice();
+  const shape: TDraftShape = { ...(d.target?.id ? { id: d.target.id } : {}), name: d.name.trim(), closed: d.kind !== "line", points: pts, shown: pts };
+  const list = d.kind === "slow" ? slow : walls;
+  const at = d.target ? list.value.indexOf(d.target) : -1;
+  if (at >= 0) list.value.splice(at, 1, shape);
+  else list.value.push(shape);
+  if (d.kind === "slow") slowDirty.value = true;
+  else wallsDirty.value = true;
+  cancelDraw();
+}
+
+/* What the plan draws: the editor's walls / slow zones (closed ones closed) and the read-only safe zones. */
+const close = (pts: TShare[], closed: boolean) => (closed && pts.length > 2 ? [...pts, pts[0]!] : pts);
+const drawn = computed(() => [
+  ...walls.value.map((w) => ({ kind: "wall" as const, name: w.name, points: close(w.shown, w.closed) })),
+  ...slow.value.map((z) => ({ kind: "slow" as const, name: z.name, points: z.shown })),
+  ...safe.value.map((z) => ({ kind: "safe" as const, name: z.name, points: z.points })),
+]);
+
+function save(kind: "wall" | "slow") {
+  if (!map.value) return;
+  emit("apply", zonesChange(map.value.mapId, kind, kind === "wall" ? loadedWalls.value : loadedSlow.value, kind === "wall" ? walls.value : slow.value), { map: map.value.name });
+}
+</script>

package/composables/useRobots.ts

@@ -347,6 +347,34 @@ export default function useRobots() {
     });
   }
 
+  /**
+   * `emergencyStop` (PadBot): stop everything now - one tap, no confirm. The
+   * answer says which way it reached the robot (live link and / or PadBot's cloud).
+   */
+  function emergencyStopRobot(id: string) {
+    return useNuxtApp().$api<{ ok: boolean; live: boolean; rest: boolean; message: string; holdMinutes?: number }>(
+      `/api/robots/${id}/emergency-stop`,
+      { method: "POST", query: { appSlug }, body: {} },
+    );
+  }
+
+  /** Super Admin setup: what can be changed now, read fresh from the maker's cloud (`mapId` picks the map). */
+  function getRobotSetup(id: string, mapId?: string | null) {
+    return useNuxtApp().$api<Record<string, any>>(`/api/robots/${id}/setup`, {
+      method: "GET",
+      query: { appSlug, ...(mapId ? { mapId } : {}) },
+    });
+  }
+
+  /** Super Admin setup: ONE change (`{ action, ... }`); answers the maker's read-back. 400 carries the plain reason. */
+  function applyRobotSetup(id: string, change: Record<string, unknown>) {
+    return useNuxtApp().$api<{ ok: boolean; summary: string; readBack: unknown }>(`/api/robots/${id}/setup`, {
+      method: "POST",
+      query: { appSlug },
+      body: change,
+    });
+  }
+
   /** `patrolHistory`: past patrols, newest first. */
   function getPatrolHistory(id: string, { page = 1, limit = 10 } = {}) {
     return useNuxtApp().$api<{ items: any[]; total: number; pages: number }>(`/api/robots/${id}/patrol-history`, {
@@ -594,6 +622,9 @@ export default function useRobots() {
   }
 
   return {
+    emergencyStopRobot,
+    getRobotSetup,
+    applyRobotSetup,
     listBuildingMaps,
     listSiteBuildingMaps,
     getFleetCoreBuilding,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "4.123.0",
+  "version": "4.124.0",
   "author": "7365admin1",
   "main": "./nuxt.config.ts",
   "//files": "What a consumer extending this layer actually loads. Without this npm ships the whole working tree - the changesets, the CI workflows, the render harness in tools/ and any scratch directory that happened to exist at publish time. Nuxt resolves a layer by directory, so every runtime directory below has to stay listed; adding a new top-level runtime directory means adding it here too.",

package/utils/robot-config.ts

@@ -0,0 +1,158 @@
+/**
+ * Super Admin robot setup screens (Ounitech zones / schedules / settings,
+ * PadBot target points) and the emergency stop: the pure parts - the change
+ * each screen sends, the one-sentence confirm, day and time words.
+ * Pure: no Vue, no Nuxt (tested in robot-config.test.ts). The server validates
+ * again and reads every change back from the maker's cloud.
+ */
+
+export type TShare = { x: number; y: number };
+export type TSetupShape = { id: string; name: string; kind: "wall" | "slow" | "safe"; closed: boolean; points: TShare[] };
+/** A shape as the editor holds it: `points` only when it was drawn or redrawn here. */
+export type TDraftShape = { id?: string; name: string; closed: boolean; points?: TShare[]; shown: TShare[] };
+
+const DAY = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+
+/** [1..7] (Monday first, the vendor's numbering) -> "Every day" / "Mon-Fri" / "Mon, Wed". */
+export function daysText(days: unknown): string {
+  const d = [...new Set((Array.isArray(days) ? days : []).filter((x) => Number.isInteger(x) && x >= 1 && x <= 7))].sort((a, b) => a - b) as number[];
+  if (!d.length) return "No days";
+  if (d.length === 7) return "Every day";
+  if (d.join() === "1,2,3,4,5") return "Mon-Fri";
+  if (d.join() === "6,7") return "Weekends";
+  return d.map((x) => DAY[x - 1]).join(", ");
+}
+
+export const DAY_CHOICES = DAY.map((title, i) => ({ title, value: i + 1 }));
+
+/** Same-day window check, in the words the screen shows. Empty = fine. */
+export function scheduleProblem(start: string, end: string, days: number[]): string {
+  const hhmm = /^([01]\d|2[0-3]):[0-5]\d$/;
+  if (!hhmm.test(start) || !hhmm.test(end)) return "Enter the start and end as HH:MM.";
+  if (end <= start) return "The end time must be after the start time (same day).";
+  if (!days.length) return "Pick at least one day.";
+  return "";
+}
+
+/** The editor's starting list: every saved wall / slow zone, untouched (no `points` = keep the robot's own geometry). */
+export function draftsFrom(shapes: TSetupShape[] | null | undefined): TDraftShape[] {
+  return (shapes ?? []).map((s) => ({ id: s.id || undefined, name: s.name || "Unnamed", closed: s.closed, shown: s.points }));
+}
+
+/**
+ * The `zones` change for one map and one kind: the FULL list (the robot's save
+ * replaces the whole list), `known` = the ids this screen loaded, so a list
+ * changed in the maker's app meanwhile is refused rather than overwritten.
+ */
+export function zonesChange(mapId: string, kind: "wall" | "slow", loaded: TSetupShape[] | null | undefined, drafts: TDraftShape[]) {
+  return {
+    action: "zones",
+    mapId,
+    kind,
+    known: (loaded ?? []).map((s) => s.id).filter(Boolean),
+    items: drafts.map((d) => ({
+      ...(d.id ? { id: d.id } : {}),
+      name: d.name.trim() || "Unnamed",
+      ...(d.points ? { points: d.points.map((p) => ({ x: round2(p.x), y: round2(p.y) })), closed: d.closed } : {}),
+    })),
+  };
+}
+
+const round2 = (v: number) => Math.round(v * 100) / 100;
+
+/** Only the settings the person changed (the server refuses "nothing changed"). */
+export function settingsDiff(loaded: Array<{ key: string; value: unknown }> | null | undefined, edited: Record<string, unknown>) {
+  const out: Record<string, boolean | number> = {};
+  for (const s of loaded ?? []) {
+    if (!(s.key in edited)) continue;
+    const v = edited[s.key];
+    const want = typeof s.value === "boolean" ? v === true : Number(v);
+    if (typeof want === "number" && !Number.isFinite(want)) continue;
+    if (want !== s.value) out[s.key] = want;
+  }
+  return out;
+}
+
+/** The one sentence the confirm dialog says before a setup change is sent (owner: say what will happen). */
+export function setupConfirmText(change: Record<string, any>, ctx: { robot?: string; map?: string } = {}): { title: string; body: string; action: string } {
+  const robot = ctx.robot || "the robot";
+  const map = ctx.map ? `map "${ctx.map}"` : "this map";
+  switch (change.action) {
+    case "zones": {
+      const n = Array.isArray(change.items) ? change.items.length : 0;
+      const what = change.kind === "wall" ? "virtual walls and no-go areas" : "slow zones";
+      return {
+        title: `Save ${what} to ${robot}?`,
+        body: `The robot's ${what} on ${map} are replaced by these ${n}. It follows them on its next move. Anything removed here is removed from the robot.`,
+        action: "Save to robot",
+      };
+    }
+    case "auto-walls":
+      return {
+        title: "Draw virtual walls automatically?",
+        body: `Ounitech draws walls around the obstacles on ${robot}'s current map. It may replace walls drawn by hand; check the map afterwards and fix any wall here.`,
+        action: "Draw walls",
+      };
+    case "plan-save":
+      return {
+        title: change.planId ? "Change this cleaning schedule?" : "Add this cleaning schedule?",
+        body: `${robot} will start cleaning ${daysText(change.days)} ${change.startTime}-${change.endTime} (robot's local time)${change.enabled === false ? ", switched off for now" : ""}. Schedules run only while "Schedules switched on" is On in its settings.`,
+        action: "Save schedule",
+      };
+    case "plan-enable":
+      return { title: `Switch this schedule ${change.enabled ? "on" : "off"}?`, body: change.enabled ? `${robot} will start cleaning at the scheduled times.` : `${robot} will not start this schedule until it is switched on again.`, action: change.enabled ? "Switch on" : "Switch off" };
+    case "plan-delete":
+      return { title: "Delete this cleaning schedule?", body: `It is removed from ${robot} and from the Ounitech app. This can't be undone.`, action: "Delete" };
+    case "power-save":
+      return {
+        title: change.planId ? "Change this timed switch?" : "Add a timed switch?",
+        body: `${robot} will switch itself ${change.switchTo} at ${change.time} on ${daysText(change.days)} (robot's local time).${change.switchTo === "off" ? " A robot switched off does not clean or answer commands until it is switched on." : ""}`,
+        action: "Save",
+      };
+    case "power-enable":
+      return { title: `Switch this timed on/off ${change.enabled ? "on" : "off"}?`, body: change.enabled ? "It will run at its time again." : "It stops running until switched on again.", action: change.enabled ? "Switch on" : "Switch off" };
+    case "power-delete":
+      return { title: "Delete this timed switch?", body: `It is removed from ${robot}. This can't be undone.`, action: "Delete" };
+    case "robot-name":
+      return { title: "Rename the robot in Ounitech?", body: `${robot} will show as "${change.name}" in the Ounitech app. Its name here does not change (use Edit for that).`, action: "Rename" };
+    case "scene-name":
+      return { title: "Rename the Ounitech site?", body: `The robot's site will show as "${change.name}" in the Ounitech app.`, action: "Rename" };
+    case "map-name":
+      return { title: "Rename this map?", body: `${map} will show as "${change.name}" here and in the Ounitech app.`, action: "Rename" };
+    case "dock-here":
+      return {
+        title: "Save the dock where the robot is now?",
+        body: `Only do this with ${robot} sitting on its dock and charging. The robot returns to this spot to charge from now on; a wrong spot means it can't find its dock.`,
+        action: "Save dock",
+      };
+    case "switch-floor":
+      return {
+        title: `Switch the robot to floor ${change.floorNo}?`,
+        body: `Only after ${robot} has been physically taken to floor ${change.floorNo}. It then uses that floor's map; on the wrong floor it gets lost and may bump into things.`,
+        action: "Switch floor",
+      };
+    case "settings": {
+      const keys = Object.keys(change.values ?? {});
+      return { title: "Change the robot's settings?", body: `${keys.length} setting${keys.length === 1 ? "" : "s"} will change on ${robot} straight away.`, action: "Save settings" };
+    }
+    case "point-add":
+      return {
+        title: `Add point "${change.name}"?`,
+        body: change.at === "robot" ? `It is saved where ${robot} stands now, facing the way it faces.` : `It is saved where you clicked on ${map}. The robot can then be sent there.`,
+        action: "Add point",
+      };
+    case "point-update":
+      return { title: "Change this point?", body: `Patrol routes and buttons that use it go to the new place / name from now on.`, action: "Save point" };
+    case "point-delete":
+      return { title: "Delete this point?", body: `It is removed from ${robot}'s map. Patrol routes that use it may stop working; check them in the PadBot app.`, action: "Delete point" };
+    default:
+      return { title: "Send this change?", body: "", action: "Send" };
+  }
+}
+
+/** The emergency stop's answer in plain words (never "accepted" when nothing reached the robot). */
+export function estopResultText(r: { live?: boolean; rest?: boolean; message?: string } | null | undefined): string {
+  if (!r) return "";
+  if (r.message) return r.message;
+  return r.live || r.rest ? "Emergency stop sent." : "The emergency stop did not reach the robot. Press the red button on the robot.";
+}

package/utils/robot-display.ts

@@ -1707,6 +1707,7 @@ export function robotAbilities(input: {
     on("sendToDock") && "returns to its charger",
     on("liveVideo") && "streams live video",
     on("manualDrive") && "can be driven by hand",
+    on("emergencyStop") && "stops at once with Emergency stop",
   ].filter(Boolean) as string[];
   const reports = [
     on("battery") && "battery",

package/utils/robot-setup.ts

@@ -186,14 +186,12 @@ export function robotSetupSteps(input: TSetupInput): TSetupStep[] {
 
   // 5. Floors present: one per floor the robots report.
   const floors = floorsOf(map);
-  const reported = [
-    ...new Set<number>(
-      Object.values(input.states ?? {})
-        .filter((s) => s?.ok && s.floorKnown === true && Number.isInteger(s.floorNo))
-        .map((s) => Number(s.floorNo)),
-    ),
-  ];
+  const onFloor = (robots ?? [])
+    .map((r) => ({ name: String(r?.name || "A robot"), s: input.states?.[String(r?._id)] }))
+    .filter((x) => x.s?.ok && x.s.floorKnown === true && Number.isInteger(x.s.floorNo));
+  const reported = [...new Set<number>(onFloor.map((x) => Number(x.s!.floorNo)))];
   const missing = reported.filter((f) => !floors.includes(f));
+  const who = (f: number) => onFloor.filter((x) => Number(x.s!.floorNo) === f).map((x) => x.name).join(", ");
   if (map === undefined) {
     steps.push({ key: "floors", title: "Floors on the map", status: "check", reason: "Could not read the saved building map.", button: { label: "Open building map", target: "map" } });
   } else if (!map) {
@@ -206,7 +204,7 @@ export function robotSetupSteps(input: TSetupInput): TSetupStep[] {
       reason: !floors.length
         ? "The saved map has no floors. Use Edit map → Add floor."
         : missing.length
-          ? `Robots report ${missing.map(floorName).join(", ")}, which the map does not have. Add ${missing.length === 1 ? "it" : "them"} in Edit map → Add floor.`
+          ? `${missing.map((f) => `${who(f)} report${who(f).includes(",") ? "" : "s"} ${floorName(f)}`).join("; ")} - the map has no such floor (it has ${floors.map(floorName).join(", ")}). Add it in Edit map → Add floor, or check the floor set in the robot's own app.`
           : `${floors.map(floorName).join(", ")}${reported.length ? " - every floor the robots report." : "."}`,
       button: { label: "Edit floors", target: "map" },
     });
@@ -268,7 +266,8 @@ export function robotSetupSteps(input: TSetupInput): TSetupStep[] {
           ? "Floor and door are read from the real lift."
           : "Floor and door not decoded yet - waiting on the lift company's register list."
         : undefined,
-      button: { label: up.length ? "Open lift queue" : "Connect gateway", target: "lifts" },
+      // An existing (not connected) gateway is checked on the lift queue; Connect there would replace its code.
+      button: { label: up.length || gws.length ? "Open lift queue" : "Connect gateway", target: "lifts" },
     });
   }