@integrity-labs/agt-cli 0.28.521 → 0.28.522

package/dist/{chunk-UAHIRLPO.js → chunk-WIQCLSZY.js}

@@ -42,7 +42,7 @@ import {
   resolveConnectivityProbe,
   worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "./chunk-STNEJC5S.js";
+} from "./chunk-4GTDD2I5.js";
 import {
   parsePsRows
 } from "./chunk-XWVM4KPK.js";
@@ -5317,7 +5317,7 @@ function exchangeFailureKind(err) {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.521" : "dev";
+var agtCliVersion = true ? "0.28.522" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -8629,4 +8629,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-UAHIRLPO.js.map
+//# sourceMappingURL=chunk-WIQCLSZY.js.map

package/dist/{claude-pair-runtime-PFMWZ66R.js → claude-pair-runtime-7W7LSW73.js}

@@ -100,7 +100,7 @@ async function spawnPairSession(session) {
     return { ok: true };
   } catch {
   }
-  const { resolveClaudeBinary } = await import("./persistent-session-DNENZXT4.js");
+  const { resolveClaudeBinary } = await import("./persistent-session-5GMZKV37.js");
   const claudeBin = resolveClaudeBinary();
   const pairEnv = {
     ...process.env,
@@ -373,4 +373,4 @@ export {
   startClaudePair,
   submitClaudePairCode
 };
-//# sourceMappingURL=claude-pair-runtime-PFMWZ66R.js.map
+//# sourceMappingURL=claude-pair-runtime-7W7LSW73.js.map

package/dist/lib/manager-worker.js

@@ -53,7 +53,7 @@ import {
   safeWriteJsonAtomic,
   setConfigHash,
   tripClass
-} from "../chunk-UAHIRLPO.js";
+} from "../chunk-WIQCLSZY.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -177,7 +177,7 @@ import {
   toOpencodeModel,
   transcriptActivityAgeSeconds,
   writeEgressAllowlist
-} from "../chunk-STNEJC5S.js";
+} from "../chunk-4GTDD2I5.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
@@ -10106,7 +10106,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.521" : "dev";
+var agtCliVersion = true ? "0.28.522" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -11314,7 +11314,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-DNENZXT4.js");
+      const { collectDiagnostics } = await import("../persistent-session-5GMZKV37.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames, quarantineEntriesFor, claudeMdSizeFor)
@@ -11421,7 +11421,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-DNENZXT4.js");
+      const { collectDiagnostics } = await import("../persistent-session-5GMZKV37.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames, quarantineEntriesFor, claudeMdSizeFor) : void 0;
       let tailscaleHostname;
@@ -11536,7 +11536,7 @@ async function pollCycle() {
         collectResponsivenessProbes,
         collectPanelessActivityProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-V7CP5ML3.js");
+      } = await import("../responsiveness-probe-52IZOP2M.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -11600,7 +11600,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-V7CP5ML3.js");
+        } = await import("../responsiveness-probe-52IZOP2M.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-NDP36U7O.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -15108,7 +15108,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
     void api.post("/host/restart-ack", { host_id: hostId, agent_id: agentId, restart_requested_at: requestedAt }).catch((err) => log(`[restart-lane] ack failed for '${codeName}': ${err.message}`));
     void (async () => {
       try {
-        const { collectDiagnostics } = await import("../persistent-session-DNENZXT4.js");
+        const { collectDiagnostics } = await import("../persistent-session-5GMZKV37.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor)
@@ -15158,7 +15158,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-DNENZXT4.js");
+      const { collectDiagnostics } = await import("../persistent-session-5GMZKV37.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor)
@@ -15676,7 +15676,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-PFMWZ66R.js");
+  } = await import("../claude-pair-runtime-7W7LSW73.js");
   for (const pairId of pendingResp.cancelled_pair_ids ?? []) {
     log(`[claude-pair] sweeping orphan tmux session for pair ${pairId.slice(0, 8)}`);
     const killed = await killPairSession(pairTmuxSession(pairId));

package/dist/mcp/direct-chat-channel.js

@@ -32140,6 +32140,11 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
   var commentEnabled = false; // armed when the viewer may comment (ENG-6847 right-click)
   var editing = null;         // the element currently in edit mode
   var bar = null;             // the Save/Cancel toolbar
+  // ENG-8477: the viewer has explicitly turned editing ON from the shell. Only
+  // then does the bridge look underneath the artefact's own overlays. See the
+  // long note on the window-capture click handler for why this is a mode and
+  // not just always-on.
+  var editMode = false;
 
   // Element-child indices from <body> down to el. Counts ELEMENT children only
   // (children, not childNodes), matching how the server walks source_html; our
@@ -32194,6 +32199,55 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
       return null;
     }catch(e){ return null; }
   }
+  // ENG-8477: the topmost element under the pointer that we could actually edit,
+  // looking THROUGH anything the artefact has laid over its own content.
+  //
+  // elementsFromPoint returns the full hit stack, front to back. We walk it from
+  // the front and take the first genuinely editable element, skipping our own
+  // injected UI. An artefact overlay is skipped for free: it is an empty div, so
+  // editable() rejects it on the text check and we keep walking.
+  //
+  // Returns null when there is nothing editable under the pointer at all, which
+  // is the signal to leave the click completely alone.
+  function editableAtPoint(x,y){
+    var stack;
+    try{ stack=document.elementsFromPoint(x,y)||[]; }catch(e){ return null; }
+    for(var i=0;i<stack.length;i++){
+      var el=stack[i];
+      if(!el || el.nodeType!==1) continue;
+      if(el.closest && el.closest('[data-al-noedit]')) continue; // our toolbar, not content
+      if(editable(el)||inlineOnlyEditable(el)) return el;
+    }
+    return null;
+  }
+  // The caret probe (caretRangeFromPoint) reports on the TOPMOST element at the
+  // point, so an overlay swallows it exactly as it swallows the click - it hands
+  // back the overlay div, not the text underneath. Neutralise everything stacked
+  // above the target for the length of the probe, then put it back. The restore
+  // is in a finally and runs before the browser can paint, so nothing flickers
+  // and no artefact state is left modified.
+  // This re-queries elementsFromPoint rather than reusing the caller's stack, so
+  // target is NOT guaranteed to still be in it. Find target's index first and
+  // mute only the prefix in front of it: a not-found target must fall back to the
+  // plain probe, because muting the whole stack would neutralise target and its
+  // ancestors too - a wider style mutation than intended, for a probe whose
+  // result the caller then rejects anyway.
+  function textNodeAtPointThrough(x,y,target){
+    var stack;
+    try{ stack=document.elementsFromPoint(x,y)||[]; }catch(e){ return textNodeAtPoint(x,y); }
+    var cut=-1, i;
+    for(i=0;i<stack.length;i++){ if(stack[i]===target){ cut=i; break; } }
+    if(cut<0) return textNodeAtPoint(x,y);
+    var muted=[];
+    for(i=0;i<cut;i++){
+      muted.push([stack[i], stack[i].style ? stack[i].style.pointerEvents : '']);
+      try{ stack[i].style.pointerEvents='none'; }catch(e){}
+    }
+    try{ return textNodeAtPoint(x,y); }
+    finally{
+      for(i=0;i<muted.length;i++){ try{ muted[i][0].style.pointerEvents=muted[i][1]||''; }catch(e){} }
+    }
+  }
   // Index of a text node among its parent's child TEXT nodes, in order - the same
   // counting the server uses to re-locate it in source_html (ENG-6856).
   function textIndexOf(container, tn){
@@ -32303,6 +32357,105 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
       e.preventDefault(); e.stopPropagation(); startEditTextNode(tn, el);
     }
   }, true);
+  // ENG-8477: reach content the artefact covers with its OWN overlay.
+  //
+  // A deck built from the canonical template lays two full-viewport click zones
+  // over its slides (.clickzone, position:fixed, z-index:40) to page forward and
+  // back. The template's own comment says it plainly: "the click zones sit above
+  // slide content by design, so any interactive element inside a slide needs
+  // position:relative + a higher z-index to stay clickable". Slide TEXT is not an
+  // interactive element and never gets one.
+  //
+  // So every click a viewer aimed at a paragraph landed on #zone-prev/#zone-next.
+  // The handler above read e.target, got an empty div, editable() rejected it on
+  // the text check, and no editor opened - while the zone's own handler paged the
+  // deck. A single-page artefact has no zones and the identical bridge works
+  // perfectly on it, which is precisely why editing "works in web page formats
+  // but not decks". Verified on real published content, not just the template.
+  //
+  // Why a MODE rather than always-on. One press cannot mean both "page the deck"
+  // and "edit this text". The zones are the deck's primary navigation, so
+  // silently stealing clicks from them would trade one broken gesture for
+  // another. The shell gives an armed viewer an explicit Edit-text toggle; until
+  // they turn it on, every line below is inert and the artefact behaves exactly
+  // as it does today. Anonymous viewers never arm at all.
+  //
+  // Why window + capture. Same phase argument as ENG-8500: the artefact's script
+  // is appended before the bridge, so registration order cannot be won, but the
+  // capture path runs window -> document -> ... -> target and therefore beats a
+  // handler bound to the zone itself no matter when it was registered.
+  // stopImmediatePropagation then keeps the deck from also paging.
+  //
+  // Deliberately general: nothing here knows about .clickzone or any class name.
+  // It fixes any artefact that covers its own content.
+  window.addEventListener('click', function(e){
+    if(!editEnabled || !editMode || editing) return;
+    var sel=document.getSelection(); if(sel && String(sel).trim()) return; // selection => comment flow
+    var t=e.target;
+    // Our own toolbar (Save/Cancel) must keep its clicks.
+    if(t && t.closest && t.closest('[data-al-noedit]')) return;
+    // Already directly on editable content: the document-level handler above
+    // covers it, and duplicating the work here would start the edit twice.
+    if(editable(t)||inlineOnlyEditable(t)) return;
+    var el=editableAtPoint(e.clientX, e.clientY);
+    // Nothing editable under the pointer - leave the click completely alone so
+    // click-to-page still works while the viewer is moving between slides.
+    if(!el) return;
+    // Suppress ONLY once an edit is actually starting. Suppressing up front left
+    // the inline-only fallback below as a dead click: no editor opened AND the
+    // deck could not page, because the event was already stopped.
+    if(editable(el)){ e.preventDefault(); e.stopImmediatePropagation(); startEdit(el); return; }
+    var tn=textNodeAtPointThrough(e.clientX, e.clientY, el);
+    if(tn && tn.parentElement===el && (tn.nodeValue||'').trim()){
+      e.preventDefault(); e.stopImmediatePropagation(); startEditTextNode(tn, el); return;
+    }
+    // An inline-only container whose exact text run we could not resolve (no
+    // caret API, or the point fell between runs). Editing the whole container
+    // would flatten its nested markup, so leave the click to the artefact and
+    // let it page as it normally would.
+  }, true);
+  // ENG-8477: the same deck template pulls focus back to the document on every
+  // pointer press, to keep its arrow keys working when the iframe loses focus:
+  //
+  //   function grabFocus(){ try{ window.focus(); document.body.focus(); }catch(e){} }
+  //   addEventListener('pointerdown', grabFocus);
+  //
+  // A bare addEventListener at artefact top level is window + bubble phase, so a
+  // window CAPTURE listener still gets there first. Without this guard, clicking
+  // into an open editor to place the caret hands focus straight to <body> and the
+  // viewer cannot type - a second, independent breaker that would have survived
+  // the overlay fix on its own.
+  //
+  // Scoped as tightly as it can be: only while an edit is open, and only for a
+  // press that lands inside the editor. A press anywhere else is the viewer
+  // leaving, and the artefact keeps it.
+  window.addEventListener('pointerdown', function(e){
+    if(!editing) return;
+    var t=e.target;
+    if(t!==editing && !(editing.contains && t && t.nodeType && editing.contains(t))) return;
+    e.stopImmediatePropagation();
+  }, true);
+  // ENG-8477: the hover affordance has the same blind spot as the click did -
+  // mouseover reports the overlay, so a viewer in edit mode would get no cue that
+  // slide text can be edited at all. Probing the stack on every mousemove would
+  // be wasteful, so this only runs in edit mode, only when the direct target is
+  // not already editable (that case the mouseover handler above still covers),
+  // and no more than once per ~80ms.
+  var hoverProbeAt=0, hoverEl=null;
+  function clearDeepHover(){
+    if(hoverEl && hoverEl!==editing && hoverEl.__alHover){ try{ hoverEl.style.outline=''; }catch(e){} hoverEl.__alHover=0; }
+    hoverEl=null;
+  }
+  document.addEventListener('mousemove', function(e){
+    if(!editEnabled || !editMode || editing){ clearDeepHover(); return; }
+    var t=e.target;
+    if(editable(t)||inlineOnlyEditable(t)){ clearDeepHover(); return; }
+    var now=Date.now(); if(now-hoverProbeAt<80) return; hoverProbeAt=now;
+    var el=editableAtPoint(e.clientX, e.clientY);
+    if(el===hoverEl) return;
+    clearDeepHover();
+    if(el){ try{ el.style.outline=el.style.outline||'1px dashed rgba(110,231,183,.6)'; }catch(e){} el.__alHover=1; hoverEl=el; }
+  });
   // ENG-8500: while the inline editor is focused, the artefact's OWN keyboard
   // handlers must not see the keystroke.
   //
@@ -32394,6 +32547,13 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
     var d=e.data; if(!d || d['${MARKUP_CONTROL_MARKER}']!==true) return;
     if(d.type==='enable-edit'){ editEnabled=true; }
     else if(d.type==='enable-comment'){ commentEnabled=true; }
+    // ENG-8477: the viewer toggled Edit text in the shell. Turning it OFF must
+    // also close anything open and drop the hover cue, or the artefact is left
+    // wearing our outlines with no way to clear them.
+    else if(d.type==='set-edit-mode'){
+      editMode = !!d.on;
+      if(!editMode){ if(editing) endEdit(false); clearDeepHover(); }
+    }
     else if(d.type==='edit-result'){
       if(d.ok){ /* republish hot-swaps the iframe; nothing to do */ }
       else { /* leave the (now non-editable) text; the published version is the source of truth */ }

package/dist/mcp/origami.js

@@ -38478,6 +38478,11 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
   var commentEnabled = false; // armed when the viewer may comment (ENG-6847 right-click)
   var editing = null;         // the element currently in edit mode
   var bar = null;             // the Save/Cancel toolbar
+  // ENG-8477: the viewer has explicitly turned editing ON from the shell. Only
+  // then does the bridge look underneath the artefact's own overlays. See the
+  // long note on the window-capture click handler for why this is a mode and
+  // not just always-on.
+  var editMode = false;
 
   // Element-child indices from <body> down to el. Counts ELEMENT children only
   // (children, not childNodes), matching how the server walks source_html; our
@@ -38532,6 +38537,55 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
       return null;
     }catch(e){ return null; }
   }
+  // ENG-8477: the topmost element under the pointer that we could actually edit,
+  // looking THROUGH anything the artefact has laid over its own content.
+  //
+  // elementsFromPoint returns the full hit stack, front to back. We walk it from
+  // the front and take the first genuinely editable element, skipping our own
+  // injected UI. An artefact overlay is skipped for free: it is an empty div, so
+  // editable() rejects it on the text check and we keep walking.
+  //
+  // Returns null when there is nothing editable under the pointer at all, which
+  // is the signal to leave the click completely alone.
+  function editableAtPoint(x,y){
+    var stack;
+    try{ stack=document.elementsFromPoint(x,y)||[]; }catch(e){ return null; }
+    for(var i=0;i<stack.length;i++){
+      var el=stack[i];
+      if(!el || el.nodeType!==1) continue;
+      if(el.closest && el.closest('[data-al-noedit]')) continue; // our toolbar, not content
+      if(editable(el)||inlineOnlyEditable(el)) return el;
+    }
+    return null;
+  }
+  // The caret probe (caretRangeFromPoint) reports on the TOPMOST element at the
+  // point, so an overlay swallows it exactly as it swallows the click - it hands
+  // back the overlay div, not the text underneath. Neutralise everything stacked
+  // above the target for the length of the probe, then put it back. The restore
+  // is in a finally and runs before the browser can paint, so nothing flickers
+  // and no artefact state is left modified.
+  // This re-queries elementsFromPoint rather than reusing the caller's stack, so
+  // target is NOT guaranteed to still be in it. Find target's index first and
+  // mute only the prefix in front of it: a not-found target must fall back to the
+  // plain probe, because muting the whole stack would neutralise target and its
+  // ancestors too - a wider style mutation than intended, for a probe whose
+  // result the caller then rejects anyway.
+  function textNodeAtPointThrough(x,y,target){
+    var stack;
+    try{ stack=document.elementsFromPoint(x,y)||[]; }catch(e){ return textNodeAtPoint(x,y); }
+    var cut=-1, i;
+    for(i=0;i<stack.length;i++){ if(stack[i]===target){ cut=i; break; } }
+    if(cut<0) return textNodeAtPoint(x,y);
+    var muted=[];
+    for(i=0;i<cut;i++){
+      muted.push([stack[i], stack[i].style ? stack[i].style.pointerEvents : '']);
+      try{ stack[i].style.pointerEvents='none'; }catch(e){}
+    }
+    try{ return textNodeAtPoint(x,y); }
+    finally{
+      for(i=0;i<muted.length;i++){ try{ muted[i][0].style.pointerEvents=muted[i][1]||''; }catch(e){} }
+    }
+  }
   // Index of a text node among its parent's child TEXT nodes, in order - the same
   // counting the server uses to re-locate it in source_html (ENG-6856).
   function textIndexOf(container, tn){
@@ -38641,6 +38695,105 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
       e.preventDefault(); e.stopPropagation(); startEditTextNode(tn, el);
     }
   }, true);
+  // ENG-8477: reach content the artefact covers with its OWN overlay.
+  //
+  // A deck built from the canonical template lays two full-viewport click zones
+  // over its slides (.clickzone, position:fixed, z-index:40) to page forward and
+  // back. The template's own comment says it plainly: "the click zones sit above
+  // slide content by design, so any interactive element inside a slide needs
+  // position:relative + a higher z-index to stay clickable". Slide TEXT is not an
+  // interactive element and never gets one.
+  //
+  // So every click a viewer aimed at a paragraph landed on #zone-prev/#zone-next.
+  // The handler above read e.target, got an empty div, editable() rejected it on
+  // the text check, and no editor opened - while the zone's own handler paged the
+  // deck. A single-page artefact has no zones and the identical bridge works
+  // perfectly on it, which is precisely why editing "works in web page formats
+  // but not decks". Verified on real published content, not just the template.
+  //
+  // Why a MODE rather than always-on. One press cannot mean both "page the deck"
+  // and "edit this text". The zones are the deck's primary navigation, so
+  // silently stealing clicks from them would trade one broken gesture for
+  // another. The shell gives an armed viewer an explicit Edit-text toggle; until
+  // they turn it on, every line below is inert and the artefact behaves exactly
+  // as it does today. Anonymous viewers never arm at all.
+  //
+  // Why window + capture. Same phase argument as ENG-8500: the artefact's script
+  // is appended before the bridge, so registration order cannot be won, but the
+  // capture path runs window -> document -> ... -> target and therefore beats a
+  // handler bound to the zone itself no matter when it was registered.
+  // stopImmediatePropagation then keeps the deck from also paging.
+  //
+  // Deliberately general: nothing here knows about .clickzone or any class name.
+  // It fixes any artefact that covers its own content.
+  window.addEventListener('click', function(e){
+    if(!editEnabled || !editMode || editing) return;
+    var sel=document.getSelection(); if(sel && String(sel).trim()) return; // selection => comment flow
+    var t=e.target;
+    // Our own toolbar (Save/Cancel) must keep its clicks.
+    if(t && t.closest && t.closest('[data-al-noedit]')) return;
+    // Already directly on editable content: the document-level handler above
+    // covers it, and duplicating the work here would start the edit twice.
+    if(editable(t)||inlineOnlyEditable(t)) return;
+    var el=editableAtPoint(e.clientX, e.clientY);
+    // Nothing editable under the pointer - leave the click completely alone so
+    // click-to-page still works while the viewer is moving between slides.
+    if(!el) return;
+    // Suppress ONLY once an edit is actually starting. Suppressing up front left
+    // the inline-only fallback below as a dead click: no editor opened AND the
+    // deck could not page, because the event was already stopped.
+    if(editable(el)){ e.preventDefault(); e.stopImmediatePropagation(); startEdit(el); return; }
+    var tn=textNodeAtPointThrough(e.clientX, e.clientY, el);
+    if(tn && tn.parentElement===el && (tn.nodeValue||'').trim()){
+      e.preventDefault(); e.stopImmediatePropagation(); startEditTextNode(tn, el); return;
+    }
+    // An inline-only container whose exact text run we could not resolve (no
+    // caret API, or the point fell between runs). Editing the whole container
+    // would flatten its nested markup, so leave the click to the artefact and
+    // let it page as it normally would.
+  }, true);
+  // ENG-8477: the same deck template pulls focus back to the document on every
+  // pointer press, to keep its arrow keys working when the iframe loses focus:
+  //
+  //   function grabFocus(){ try{ window.focus(); document.body.focus(); }catch(e){} }
+  //   addEventListener('pointerdown', grabFocus);
+  //
+  // A bare addEventListener at artefact top level is window + bubble phase, so a
+  // window CAPTURE listener still gets there first. Without this guard, clicking
+  // into an open editor to place the caret hands focus straight to <body> and the
+  // viewer cannot type - a second, independent breaker that would have survived
+  // the overlay fix on its own.
+  //
+  // Scoped as tightly as it can be: only while an edit is open, and only for a
+  // press that lands inside the editor. A press anywhere else is the viewer
+  // leaving, and the artefact keeps it.
+  window.addEventListener('pointerdown', function(e){
+    if(!editing) return;
+    var t=e.target;
+    if(t!==editing && !(editing.contains && t && t.nodeType && editing.contains(t))) return;
+    e.stopImmediatePropagation();
+  }, true);
+  // ENG-8477: the hover affordance has the same blind spot as the click did -
+  // mouseover reports the overlay, so a viewer in edit mode would get no cue that
+  // slide text can be edited at all. Probing the stack on every mousemove would
+  // be wasteful, so this only runs in edit mode, only when the direct target is
+  // not already editable (that case the mouseover handler above still covers),
+  // and no more than once per ~80ms.
+  var hoverProbeAt=0, hoverEl=null;
+  function clearDeepHover(){
+    if(hoverEl && hoverEl!==editing && hoverEl.__alHover){ try{ hoverEl.style.outline=''; }catch(e){} hoverEl.__alHover=0; }
+    hoverEl=null;
+  }
+  document.addEventListener('mousemove', function(e){
+    if(!editEnabled || !editMode || editing){ clearDeepHover(); return; }
+    var t=e.target;
+    if(editable(t)||inlineOnlyEditable(t)){ clearDeepHover(); return; }
+    var now=Date.now(); if(now-hoverProbeAt<80) return; hoverProbeAt=now;
+    var el=editableAtPoint(e.clientX, e.clientY);
+    if(el===hoverEl) return;
+    clearDeepHover();
+    if(el){ try{ el.style.outline=el.style.outline||'1px dashed rgba(110,231,183,.6)'; }catch(e){} el.__alHover=1; hoverEl=el; }
+  });
   // ENG-8500: while the inline editor is focused, the artefact's OWN keyboard
   // handlers must not see the keystroke.
   //
@@ -38732,6 +38885,13 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
     var d=e.data; if(!d || d['${MARKUP_CONTROL_MARKER}']!==true) return;
     if(d.type==='enable-edit'){ editEnabled=true; }
     else if(d.type==='enable-comment'){ commentEnabled=true; }
+    // ENG-8477: the viewer toggled Edit text in the shell. Turning it OFF must
+    // also close anything open and drop the hover cue, or the artefact is left
+    // wearing our outlines with no way to clear them.
+    else if(d.type==='set-edit-mode'){
+      editMode = !!d.on;
+      if(!editMode){ if(editing) endEdit(false); clearDeepHover(); }
+    }
     else if(d.type==='edit-result'){
       if(d.ok){ /* republish hot-swaps the iframe; nothing to do */ }
       else { /* leave the (now non-editable) text; the published version is the source of truth */ }