@mmmbuto/nexuscrew 0.9.58 → 0.9.60

package/lib/notify/routes.js

@@ -44,7 +44,7 @@ const ASK_KEYS = new Set(['question', 'options', 'session', 'target']);
 // del nodo di origine, non un chiamante locale (stessa regola di FEDERATED_KEYS).
 // `ownerNode`/`originNode` qualificano l'identita', `askId` e' l'id con cui
 // l'owner conosce la domanda (serve alla risposta per tornare sul bersaglio).
-const FEDERATED_ASK_KEYS = new Set(['askId', 'ownerNode', 'originNode', 'originCell', 'closeOutcome']);
+const FEDERATED_ASK_KEYS = new Set(['askId', 'ownerNode', 'originNode', 'originCell', 'closeOutcome', 'ownerAskTs']);
 const RATE_MAX = 6;
 const RATE_WINDOW_MS = 60 * 1000;
 const RATE_MAX_BUCKETS = 64;
@@ -160,7 +160,7 @@ function createClosureFanout({
   // l'unico lato che puo' riprovare: il ricevente non ha rotta verso l'owner).
   retry = null,
 } = {}) {
-  async function dispatch({ askId, outcome, session, retryOnFailure = true, targets = null }) {
+  async function dispatch({ askId, ownerAskTs, outcome, session, retryOnFailure = true, targets = null }) {
     if (!dispatcher) return [];
     const self = localNodeId();
     // `targets` esplicito = ritentativo: si va SOLO verso i pendenti, non di
@@ -178,7 +178,8 @@ function createClosureFanout({
           resource: '/asks',
           target,
           origin: { node: self, cell: session || 'unknown' },
-          payload: { askId, closeOutcome: outcome, ownerNode: self },
+          payload: { askId, closeOutcome: outcome, ownerNode: self,
+            ...(Number.isSafeInteger(ownerAskTs) && ownerAskTs > 0 ? { ownerAskTs } : {}) },
         });
         out.push({ target, status: r && r.status, ...(r && r.reason ? { reason: r.reason } : {}) });
       } catch (e) {
@@ -197,7 +198,7 @@ function createClosureFanout({
       const pendenti = out
         .filter((r) => !CLOSURE_DONE_STATUSES.has(r.status) && !CLOSURE_FINAL_STATUSES.has(r.status))
         .map((r) => r.target);
-      try { retry.enqueue({ askId, outcome, session, targets: pendenti }); } catch (_) {}
+      try { retry.enqueue({ askId, ownerAskTs, outcome, session, targets: pendenti }); } catch (_) {}
     }
     return out;
   }
@@ -464,7 +465,7 @@ function notifyRoutes({
         if (isClosure) {
           const owner = resolved.origin.node;
           const closed = asks.closeImported({
-            ownerId: owner, ownerAskId: b.askId, outcome: b.closeOutcome,
+            ownerId: owner, ownerAskId: b.askId, ownerAskTs: b.ownerAskTs, outcome: b.closeOutcome,
           });
           // closeImported rifiuta ({ok:false, reason:'store-unreadable'}) se lo
           // store locale e' illeggibile: l'alias NON e' stato chiuso. Rispondere
@@ -480,13 +481,17 @@ function notifyRoutes({
             const reason = closed.reason || 'store-unreadable';
             return res.status(503).json({ status: 'unavailable', reason });
           }
-          if (closed.changed && closed.ask) {
-            // Il frame porta l'id LOCALE: e' quello con cui questa UI identifica
-            // la card, e senza di esso la card resterebbe a schermo.
+          if (!closed.generationMismatch) {
+            // The frame must reach the exported view even when the store had
+            // nothing to change (alias absent, or already closed by a
+            // duplicate): a fresh page rebuilds its cards from that view, and
+            // only a generation mismatch may refuse the closure.
             notifier.deliverOnlyRaw({
               type: b.closeOutcome === 'dismissed' ? 'ask-dismissed' : 'ask-answered',
-              id: closed.ask.id,
+              id: (closed.ask && closed.ask.id) || b.askId,
               ownerId: owner,
+              ownerAskId: (closed.ask && closed.ask.ownerAskId) || b.askId,
+              ...(Number.isSafeInteger(b.ownerAskTs) && b.ownerAskTs > 0 ? { ownerAskTs: b.ownerAskTs } : {}),
             });
           }
           return res.json({ status: 'delivered', closed: closed.changed });
@@ -506,28 +511,36 @@ function notifyRoutes({
           // L'id con cui l'OWNER conosce la domanda: e' quello che la risposta
           // deve citare. Il nostro `id` locale resta nostro.
           ownerAskId: b.askId,
+          ownerAskTs: b.ownerAskTs,
           originNode: owner,
           originCell: resolved.origin.cell,
         });
         if (!out.ok) {
           return res.status(out.reason === 'cap' ? 429 : 400).json({ status: 'refused', reason: out.reason, error: out.error });
         }
+        if (out.suppressed || out.elided) {
+          const reason = out.suppressed ? 'suppressed' : 'elided';
+          try { log(`ask ingress ${owner}/${b.askId}: ${reason}, ui=0 push=0`); } catch (_) {}
+          return res.json({ status: 'delivered', ...(out.suppressed ? { suppressed: true } : { elided: true }), ownerId: owner, alertStatus: reason, alert: { ui: 0, push: 0, uiAttempted: false, pushAttempted: false } });
+        }
         const ask = out.ask;
         // deliverOnly: consegna locale alla UI, NIENTE pubblicazione sul feed e
         // niente ri-esportazione. E' l'invariante che uccide il loop A->B->A per
         // costruzione — un ask importato non torna mai indietro, esattamente
         // come una notify federata.
-        notifier.deliverOnlyRaw({ type: 'ask', ask });
-        await notifier.deliverOnly({
+        const cardUi = notifier.deliverOnlyRaw({ type: 'ask', ask });
+        const alert = await notifier.deliverOnly({
           title: `domanda da ${ask.session}`,
           body: ask.question,
           urgency: 'high',
           session: ask.session,
           lang: 'it',
-          askId: ask.id,
+          ownerId: owner, askId: ask.ownerAskId || ask.id,
+          ...(Number.isSafeInteger(ask.ownerAskTs) && ask.ownerAskTs > 0 ? { ownerAskTs: ask.ownerAskTs } : { ownerAskFingerprint: asks.askFingerprint(ask) }),
           url: `/#ask=${ask.id}`,
         });
-        return res.json({ status: 'delivered', id: ask.id, ownerId: ask.ownerId });
+        try { log(`ask ingress ${owner}/${b.askId}: accepted, cardUi=${cardUi || 0} ui=${alert.ui} push=${alert.push} alert=${alert.alertStatus}`); } catch (_) {}
+        return res.json({ status: 'delivered', id: ask.id, ownerId: ask.ownerId, deduped: out.deduped === true, cardUi: cardUi || 0, alertStatus: alert.alertStatus, alert });
       }
 
       // --- domanda locale ----------------------------------------------------
@@ -565,10 +578,11 @@ function notifyRoutes({
               ...(ask.options ? { options: ask.options } : {}),
               session: ask.session,
               askId: ask.id,
+              ownerAskTs: ask.ts,
               ownerNode: self,
             },
           });
-          fanout.push({ target, status: r && r.status, ...(r && r.reason ? { reason: r.reason } : {}) });
+          fanout.push({ target, status: r && r.status, ...(r && r.reason ? { reason: r.reason } : {}), ...(r && r.alertStatus ? { alertStatus: r.alertStatus, alert: r.alert } : {}), ...(r && r.suppressed === true ? { suppressed: true } : {}), ...(r && r.elided === true ? { elided: true } : {}), ...(r && typeof r.deduped === 'boolean' ? { deduped: r.deduped } : {}) });
         } catch (e) {
           fanout.push({ target, status: 'unknown', reason: 'dispatch-threw' });
           try { log(`ask fan-out verso ${target} fallito: ${String(e && e.message || e)}`); } catch (_) {}
@@ -588,7 +602,7 @@ function notifyRoutes({
         urgency: 'high',
         session: ask.session,
         lang: 'it',
-        askId: ask.id,
+        ownerId: self, askId: ask.id, ownerAskTs: ask.ts,
         url: `/#ask=${ask.id}`,
       });
       res.status(201).json({ id: ask.id, ...(fanout.length ? { fanout } : {}) });

package/lib/server.js

@@ -7,7 +7,8 @@ const { execFileSync } = require('node:child_process');
 const express = require('express');
 const { WebSocketServer } = require('ws');
 const { defaults, loadConfig, assertLoopback, configJsonPath } = require('./config.js');
-const { listSessions, listPanes, attachedClients, setSessionVisibility } = require('./tmux/list.js');
+const { attachedClients, setSessionVisibility, listFleetPanes, sessionsFromPanes } = require('./tmux/list.js');
+const { createTmuxReadWindow } = require('./tmux-reads.js');
 const { statiSupervisore: statiSupervisoreDi, senzaSupervisore } = require('./tmux/supervisor-pane.js');
 const { runAction, pasteToSession, submitToSession } = require('./tmux/actions.js');
 const { createSession, killSession, isProtectedSession } = require('./tmux/lifecycle.js');
@@ -53,6 +54,7 @@ const { createDispatcher } = require('./audio/dispatch.js');
 const { createCellScopeGuard } = require('./cells/scope-guard.js');
 const { createCellScope } = require('./cells/scope.js');
 const { cellIdFromTmuxSession } = require('./fleet/definitions.js');
+const { createOwnerAskScope } = require('./notify/owner-ask-scope.js');
 // Budget a tre finestre, riusato dalle notifiche federate: e' gia' scritto per
 // limitare il danno di un nodo che mente sulla propria cella (il tetto per
 // target si calcola sul NODO, che la catena visited verifica).
@@ -75,6 +77,8 @@ const { createPushService } = require('./notify/push.js');
 const { createPushRelay, createPushDedup } = require('./notify/push-relay.js');
 const { createAsksStore } = require('./notify/asks.js');
 const { createNotifier } = require('./notify/notifier.js');
+const { createAskAlertRegistry } = require('./notify/ask-alert-registry.js');
+const { canonicalAskAlert } = require('./notify/ask-alert-identity.js');
 const { createEventFeed } = require('./notify/event-feed.js');
 const { createEventFeedHistory } = require('./notify/event-feed-history.js');
 const { buildEnvelope } = require('./notify/event-feed-producers.js');
@@ -85,6 +89,7 @@ const { createAskReceipts } = require('./notify/ask-receipts.js');
 const { createAskAnswerService } = require('./notify/ask-answer-service.js');
 const { createEventFeedAsksRoutes } = require('./notify/event-feed-asks-routes.js');
 const { createAskRelay } = require('./notify/ask-relay.js');
+const { createImportedDismissalDrainer } = require('./notify/imported-dismissals.js');
 const { createAskSlotVerifier } = require('./nodes/ask-slot-verifier.js');
 const { readFederationEventsEnabled } = require('./config.js');
 
@@ -195,18 +200,21 @@ function createServer(opts = {}) {
   // alert budget and a durable (owner, eventId) registry — an event already
   // alerted never rings twice, across a replay or a restart. It is fed only by
   // the import hub below, so a local emission never takes this path.
+  const askAlertRegistry = createAskAlertRegistry({ filePath: path.join(notifyDir, 'ask-alerts.json') });
   const pushRelay = createPushRelay({
+    alertRegistry: askAlertRegistry,
     pushDedup: createPushDedup({ filePath: path.join(notifyDir, 'push-relay-dedup.json') }),
     send: (payload) => pushSvc.sendToAll(payload),
     log: opts.log || console.log,
   });
   const asksStore = createAsksStore({ dir: notifyDir });
+  const ownerAskScope = createOwnerAskScope(cfg);
   // --- Event feed (owner side) -------------------------------------------------
   // The notifier stays the single emission point; the feed is a SIDE EFFECT of
   // a local emission, never a separate path. Federated ingress and feed import
   // call deliverOnly(): local delivery that does NOT re-enter the publisher —
   // an imported event can never be re-exported, so A→B→A dies by construction.
-  const notifierBase = createNotifier({ hub: eventsHub, push: pushSvc });
+  const notifierBase = createNotifier({ hub: eventsHub, push: pushSvc, alertRegistry: askAlertRegistry });
   const feedHistory = createEventFeedHistory({
     filePath: path.join(notifyDir, 'event-feed-history.json'),
   });
@@ -264,12 +272,17 @@ function createServer(opts = {}) {
     // arriva da un altro nodo. Il fan-out e' lo stesso dell'andata e NON parte
     // per un ask importato: la chiusura di quello la decide il suo owner.
     onClosure: (kind, info) => {
-      try { notifier.emitRaw({ type: kind, id: info.askId }); } catch (_) {}
+      try {
+        const ask = asksStore.get(info.askId);
+        const ownerAskTs = ask && (ask.originNode ? ask.ownerAskTs : ask.ts);
+        notifier.emitRaw({ type: kind, id: info.askId,
+          ...(Number.isSafeInteger(ownerAskTs) && ownerAskTs > 0 ? { ownerAskTs } : {}) });
+      } catch (_) {}
       try {
         const ask = asksStore.get(info.askId);
         if (ask && !ask.originNode && closureFanout) {
           return closureFanout.dispatch({
-            askId: info.askId,
+            askId: info.askId, ownerAskTs: ask.ts,
             outcome: kind === 'ask-dismissed' ? 'dismissed' : 'answered',
             session: (ask && ask.session) || info.cellSession,
           });
@@ -368,21 +381,21 @@ function createServer(opts = {}) {
       try {
         if (frame && frame.type === 'ask' && frame.ask) {
           const ask = frame.ask;
-          const cellId = cellIdFromTmuxSession(ask.session);
+          const cellId = ownerAskScope.cellForSession(ask.session);
           if (cellId) {
             recordAndPublish({
               producer: 'ask', cellId,
-              payload: { askId: ask.id, revision: ask.revision || 0, question: ask.question, options: ask.options, session: ask.session, ts: Date.now() },
+              payload: { askId: ask.id, revision: ask.revision || 0, question: ask.question, options: ask.options, session: ask.session, askTs: ask.ts, ts: Date.now() },
             });
           }
         } else if (frame && (frame.type === 'ask-answered' || frame.type === 'ask-dismissed')) {
           const all = asksStore.list({ open: false }).concat(asksStore.list({ open: true }));
           const ask = all.find((a) => a && a.id === frame.id);
-          const cellId = ask ? cellIdFromTmuxSession(ask.session) : null;
+          const cellId = ask ? ownerAskScope.cellForSession(ask.session) : null;
           if (cellId) {
             recordAndPublish({
               producer: 'ask-closed', cellId,
-              payload: { askId: frame.id, revision: (ask && ask.revision) || 0, outcome: frame.type === 'ask-dismissed' ? 'dismissed' : 'answered', ts: Date.now() },
+              payload: { askId: frame.id, askTs: ask.ts, revision: (ask && ask.revision) || 0, outcome: frame.type === 'ask-dismissed' ? 'dismissed' : 'answered', ts: Date.now() },
             });
           }
         }
@@ -392,7 +405,23 @@ function createServer(opts = {}) {
     // Delivery-only: federated ingress and feed import land here. NO history,
     // NO publisher — an imported event is never re-exported.
     async deliverOnly(frame) { return notifierBase.emit(frame); },
-    deliverOnlyRaw(frame) { return notifierBase.emitRaw(frame); },
+    deliverOnlyRaw(frame) {
+      if (frame.type === 'ask' && frame.ask && frame.ask.ownerId) {
+        eventFeedClient.rememberLiveAsk(frame.ask.ownerId, frame.ask);
+      }
+      // An authenticated owner closure must reach the SAME exported view the
+      // live ask entered, even when the store alias was already closed or
+      // absent: a fresh page rebuilds its cards from that view. scope:'local'
+      // is a local dismissal, not the owner speaking — it keeps its own path.
+      if ((frame.type === 'ask-answered' || frame.type === 'ask-dismissed')
+        && frame.ownerId && frame.ownerAskId && frame.scope !== 'local') {
+        eventFeedClient.applyOwnerClosure(frame.ownerId, frame.ownerAskId, {
+          ownerAskTs: Number.isSafeInteger(frame.ownerAskTs) && frame.ownerAskTs > 0 ? frame.ownerAskTs : undefined,
+          outcome: frame.type === 'ask-answered' ? 'answered' : 'dismissed',
+        });
+      }
+      return notifierBase.emitRaw(frame);
+    },
     publishState: (producer, payload) => recordAndPublish({ producer, cellId: null, payload }),
   };
   const diagnostics = opts.diagnostics || createDiagnostics();
@@ -999,13 +1028,24 @@ function createServer(opts = {}) {
     cellForSession: (session) => cellIdFromTmuxSession(session),
     resolveOrigin: (req) => cellScopeOrigin.resolve(req, { requireCell: false }),
   }));
+  // UNO spawn per giro. La list-panes -a del fleet snapshot porta
+  // sessioni E supervisori insieme (lib/tmux/list.js), e lo snapshot TMUX
+  // viene coalescato entro la finestra (2 s): letture vicine di finestre o
+  // client diversi condividono lo stesso giro, chi arriva mentre il giro e'
+  // in volo aspetta quello. Oltre la finestra si rilegge. L'ENRICHMENT
+  // (outbox, preview, telemetria, attivita) resta fuori dalla cache: sono
+  // file che cambiano senza toccare tmux, e restano freschi a ogni lettura.
+  const tmuxReads = createTmuxReadWindow(async () => {
+    const panesRaw = await listFleetPanes(cfg.tmuxBin);
+    const sessions = sessionsFromPanes(panesRaw);
+    // La stessa lettura dice chi ha ancora il suo supervisore: campi 0-3
+    // delle stesse righe (parsePanes), nessuna seconda chiamata.
+    const statiSupervisore = sessions.length ? statiSupervisoreDi(panesRaw) : new Map();
+    return { sessions, statiSupervisore };
+  }, cfg.sessionsCacheMs);
   api.get('/sessions', async (_req, res) => {
     try {
-      const sessions = await listSessions(cfg.tmuxBin);
-      // UNA chiamata per giro per sapere chi ha ancora il suo supervisore.
-      const statiSupervisore = sessions.length
-        ? statiSupervisoreDi(await listPanes(cfg.tmuxBin))
-        : new Map();
+      const { sessions, statiSupervisore } = await tmuxReads.read();
       const sum = watcher.getSummary();
       const enriched = await Promise.all(sessions.map(async (s) => {
         const sample = await previews.getState(s.name);
@@ -1224,7 +1264,8 @@ function createServer(opts = {}) {
         try {
           const closed = asksStore.closeImported({ ownerId, ownerAskId: alias.ownerAskId, outcome: 'dismissed' });
           if (closed.changed && closed.ask) {
-            try { notifier.deliverOnlyRaw({ type: 'ask-dismissed', id: closed.ask.id, ownerId }); } catch (_) {}
+            try { notifier.deliverOnlyRaw({ type: 'ask-dismissed', id: closed.ask.id, ownerId, ownerAskId: closed.ask.ownerAskId,
+              ...(Number.isSafeInteger(closed.ask.ownerAskTs) && closed.ask.ownerAskTs > 0 ? { ownerAskTs: closed.ask.ownerAskTs } : {}) }); } catch (_) {}
           }
         } catch (_) { /* un alias non chiudibile non ferma gli altri */ }
       }
@@ -1238,8 +1279,8 @@ function createServer(opts = {}) {
     // verso quelli. Senza, ogni ritentativo rimanderebbe la chiusura anche a chi
     // l'ha gia' ricevuta — rumore, non danno, ma nemmeno una coda che sa cosa
     // le manca.
-    run: ({ askId, outcome, session, targets }) => (closureFanout
-      ? closureFanout.dispatch({ askId, outcome, session, retryOnFailure: false, targets })
+    run: ({ askId, ownerAskTs, outcome, session, targets }) => (closureFanout
+      ? closureFanout.dispatch({ askId, ownerAskTs, outcome, session, retryOnFailure: false, targets })
       : Promise.resolve([])),
   });
   closureFanout = createClosureFanout({
@@ -1293,7 +1334,7 @@ function createServer(opts = {}) {
     asks: asksStore,
     answerService: askAnswerService,
     receipts: askReceipts,
-    cellForSession: (session) => cellIdFromTmuxSession(session),
+    cellForSession: ownerAskScope.cellForSession,
     readonly: proxyReadonly,
   }));
   api.use('/event-feed', createEventFeedRoutes({
@@ -1307,7 +1348,8 @@ function createServer(opts = {}) {
     history: feedHistory,
     asksStore,
     fleetP,
-    cellForSession: (session) => cellIdFromTmuxSession(session),
+    cellForSession: ownerAskScope.cellForSession,
+    askScopeResolver: ownerAskScope.snapshotResolver,
     eventsEnabled,
     // Il produttore dello snapshot logga la lettura fallita degli asks: senza
     // questo wiring la riga finiva nel noop di default delle routes.
@@ -1321,6 +1363,7 @@ function createServer(opts = {}) {
   // resolves the owner from the authorized store and forwards with the peer's
   // own pair token. Uncertain outcomes are parked, never retried silently.
   const askRelay = createAskRelay({
+    availabilityBinding: dismissalBinding,
     nodesPath, slotVerifier: askReverseVerifier,
     loadStore: () => nodesStore.loadStore(nodesPath),
     peers: federatedPeers,
@@ -1334,9 +1377,94 @@ function createServer(opts = {}) {
   // 400 «ownerId, askId e text richiesti» a OGNI richiesta: la risposta
   // federata non ha mai potuto attraversare, e nessun test copriva questa
   // rotta. Difetto preesistente, trovato scrivendo il test del ritorno federato.
+  function dismissalBinding(ownerId) {
+      const st = nodesStore.loadStore(nodesPath);
+      if (!st) return null;
+      const direct = st.nodes.filter(node => node.nodeId === ownerId);
+      const cached = topologyCache.loadCache(topologyCachePath);
+      const route = cached && cached.nodes.find(node => node.instanceId === ownerId)?.route;
+      const relevant = direct.length ? direct : st.nodes.filter(node => route && route.includes(node.name));
+      return require('node:crypto').createHash('sha256').update(JSON.stringify(relevant.map(node => ({ nodeId: node.nodeId, direction: node.direction,
+        shared: node.shared, pairingRevision: node.pairingRevision || 0, localPort: node.localPort, reversePool: node.reversePool,
+        configured: accessPresets.grantsOf(node).configured, grants: accessPresets.grantsOf(node).grants }))) + JSON.stringify(route || [])).digest('hex');
+  }
+  function dismissalPeer(ownerId) {
+    const st = nodesStore.loadStore(nodesPath);
+    if (!st) return null;
+    const direct = st.nodes.filter(node => node.nodeId === ownerId);
+    if (direct.length) return direct.length === 1 ? direct[0] : null;
+    // A cached route identifies the first hop, never authorizes it or proves
+    // an outage. The current local grants and channel are checked separately.
+    const cached = topologyCache.loadCache(topologyCachePath);
+    const routes = cached && cached.nodes.filter(node => node.instanceId === ownerId);
+    if (!routes || routes.length !== 1) return null;
+    const first = st.nodes.filter(node => node.name === routes[0].route[0]);
+    return first.length === 1 ? first[0] : null;
+  }
+  function localDismissalEligibility(ownerId, askId) {
+    const peer = dismissalPeer(ownerId);
+    const storedAlias = asksStore.findImported(ownerId, askId);
+    const previous = asksStore.getImportedDismissal(ownerId, askId);
+    const view = eventFeedClient.state().views.find(item => item.ownerId === ownerId);
+    const feedAsk = view && view.asks.find(item => (item.ownerAskId || item.id) === askId);
+    const tsOf = item => { const ts = item && (Object.hasOwn(item, 'ownerAskTs') ? item.ownerAskTs : item.originNode ? null : item.ts); return Number.isSafeInteger(ts) && ts > 0 ? ts : null; };
+    let ask = storedAlias || feedAsk, ambiguous = false;
+    if (storedAlias && feedAsk) {
+      const aliasTs = tsOf(storedAlias), feedTs = tsOf(feedAsk);
+      const sameContent = asksStore.askFingerprint(storedAlias) === asksStore.askFingerprint(feedAsk);
+      if (aliasTs !== null && feedTs !== null && aliasTs !== feedTs) {
+        ask = feedTs > aliasTs ? feedAsk : storedAlias;
+        // An older visible feed cannot be acknowledged through a newer closed
+        // alias. Its current generation needs an authoritative refresh.
+        if (ask === storedAlias && (storedAlias.dismissed || storedAlias.answered)) ambiguous = true;
+      }
+      else if (!sameContent) ambiguous = true;
+      else ask = feedTs !== null && aliasTs === null ? feedAsk : storedAlias;
+    }
+    // Guards and alias mutation belong only to the selected generation.
+    const alias = storedAlias && ask && asksStore.sameImportedGeneration(storedAlias, ask) ? storedAlias : null;
+    const grants = peer && accessPresets.grantsOf(peer);
+    const cellId = ask ? cellIdFromTmuxSession(ask.session) : previous && previous.cellId;
+    const visible = !!((ask || previous) && cellId && grants && grants.configured && grants.grants.eventsAccess === true
+      && eventFeedAcl.visibilityAllows(grants.grants, cellId));
+    const blocked = !!((ask && ask.answered) || (alias && (asksStore.isAnswering(alias.id) || askReceipts.isBlocked(alias.id)))
+      || askRelay.state().some(attempt => attempt.ownerId === ownerId && attempt.askId === askId && ['sent', 'uncertain'].includes(attempt.state)));
+    const slot = peer && peer.reversePool && peer.reversePool.slots && peer.reversePool.slots[peer.reversePool.activeSlot];
+    const unavailable = !!(peer && peer.direction === 'inbound' && (!peer.shared || !slot || !Number.isInteger(slot.port)))
+      || askRelay.channelState(ownerId).unavailable;
+    return { peer, alias, previous, ask, grants, cellId, visible, blocked: blocked || ambiguous, unavailable, ambiguous };
+  }
   api.post('/asks-relay', express.json({ limit: '8kb' }), async (req, res) => {
     try {
       const b = req.body || {};
+      if (b.action === 'dismiss-local') {
+        if (proxyReadonly()) return res.status(403).json({ error: 'READONLY: mutation blocked' });
+        if (req.headers[HOP_HEADER]) return res.status(403).json({ error: 'local operator required' });
+        if (!b || Array.isArray(b) || Object.keys(b).some(key => !['action', 'ownerId', 'askId'].includes(key))
+          || !/^[a-f0-9]{32}$/.test(b.ownerId) || !/^[a-f0-9]{8}$/.test(b.askId) || b.ownerId === federatedNodeId()) {
+          return res.status(400).json({ error: 'invalid local dismissal body' });
+        }
+        try { if (!asksStore.health().readable) return res.status(503).json({ error: 'dismissal store unavailable' }); }
+        catch (_) { return res.status(503).json({ error: 'dismissal store unavailable' }); }
+        const { peer, alias, previous, ask, grants, cellId, visible, unavailable, ambiguous } = localDismissalEligibility(b.ownerId, b.askId);
+        if (!visible) return res.status(404).json({ error: 'unknown or invisible ask' });
+        if (ambiguous) return res.status(409).json({ error: 'ask generation is ambiguous; refresh the owner view', reason: 'generation-ambiguous' });
+        if (ask && ask.answered) return res.status(409).json({ error: 'ask already answered', reason: 'answered' });
+        if ((alias && (asksStore.isAnswering(alias.id) || askReceipts.isBlocked(alias.id)))
+          || askRelay.state().some(attempt => attempt.ownerId === b.ownerId && attempt.askId === b.askId && ['sent', 'uncertain'].includes(attempt.state))) {
+          return res.status(409).json({ error: 'answer requires reconciliation', reason: 'delivery-unknown-block' });
+        }
+        if (!ask && previous) return res.json({ dismissed: true, scope: 'local', ownerSync: previous.syncState === 'blocked' ? 'blocked' : 'pending' });
+        if (!unavailable) return res.status(409).json({ error: 'owner channel is not known unavailable', reason: 'owner-availability-unknown' });
+        const out = asksStore.dismissImported({ ownerId: b.ownerId, ownerAskId: b.askId, ask, cellId, retryBinding: dismissalBinding(b.ownerId),
+          syncState: grants.grants.askReplyAccess === true ? 'pending' : 'blocked' });
+        if (!out.ok) return res.status(out.reason === 'dismissal-cap' ? 429 : 503).json({ error: 'local dismissal refused', reason: out.reason });
+        notifier.deliverOnlyRaw({ type: 'ask-dismissed', id: alias ? alias.id : b.askId, ownerId: b.ownerId, ownerAskId: b.askId, scope: 'local',
+          // UI-only context also distinguishes changed content before the first snapshot.
+          askGeneration: { question: ask.question, options: ask.options || [], session: ask.session },
+          ownerAskTs: out.record.ownerAskTs, ownerSync: out.record.syncState === 'blocked' ? 'blocked' : 'pending' });
+        return res.json({ dismissed: true, scope: 'local', ownerSync: out.record.syncState === 'blocked' ? 'blocked' : 'pending' });
+      }
       if (b.action === 'dismiss') {
         const out = await askRelay.relayDismiss({ ownerId: b.ownerId, askId: b.askId });
         // Dismiss CONFERMATO dall'owner (2xx): la view del feed lo dimentica
@@ -1367,7 +1495,16 @@ function createServer(opts = {}) {
     const ownerId = typeof req.query.ownerId === 'string' ? req.query.ownerId : '';
     const askId = typeof req.query.askId === 'string' ? req.query.askId : '';
     if (!/^[a-f0-9]{32}$/.test(ownerId) || !/^[a-f0-9]{8}$/.test(askId)) return res.status(400).json({ error: 'ownerId e askId richiesti' });
-    try { res.json(await askRelay.replyCapability({ ownerId, askId })); }
+    try {
+      const remote = await askRelay.replyCapability({ ownerId, askId });
+      if (req.query.dismissals !== '1') return res.json(remote);
+      const local = localDismissalEligibility(ownerId, askId);
+      const mutable = !proxyReadonly() && !req.headers[HOP_HEADER];
+      let readable = false;
+      try { readable = asksStore.health().readable; } catch (_) {}
+      res.json({ ...remote, canDismissRemote: mutable && remote.canReply === true,
+        canDismissLocal: mutable && readable && local.visible && !local.blocked && (local.unavailable || !!local.previous) });
+    }
     catch (_) { res.json({ ownerId, askId, canReply: false, status: 'unreachable' }); }
   });
   api.get('/asks-relay/state', (_req, res) => {
@@ -1381,7 +1518,12 @@ function createServer(opts = {}) {
   // durable write.
   const importHub = {
     broadcast: (event) => {
-      eventsHub.broadcast(event);
+      const alert = event && event.type === 'notify' && canonicalAskAlert(event);
+      const claim = alert && !bridgeReadonly() ? askAlertRegistry.claim(event, 'ui') : { allowed: true };
+      if (claim.allowed) {
+        const count = eventsHub.broadcast(event);
+        if (alert && !bridgeReadonly()) askAlertRegistry.complete(event, 'ui', count);
+      }
       if (!bridgeReadonly()) pushRelay.considerImported(event);
     },
   };
@@ -1392,6 +1534,12 @@ function createServer(opts = {}) {
     }
   }
   const eventFeedClient = createEventFeedClient({
+    onViewChanged: ownerId => eventsHub.broadcast({ type: 'feed-state-changed', ownerId }),
+    onAuthoritativeAsks: (ownerId, asks) => {
+      if (!bridgeReadonly()) for (const ask of asks) askAlertRegistry.adopt(ownerId, ask, ask.ownerAskTs === undefined ? ask.ts : ask.ownerAskTs);
+    },
+    isAskDismissed: (ownerId, ask) => asksStore.isImportedDismissed(ownerId, ask),
+    onAskClosed: (ownerId, ownerAskId, outcome, ownerAskTs) => asksStore.closeImported({ ownerId, ownerAskId, outcome, ownerAskTs }),
     loadStore: () => nodesStore.loadStore(nodesPath),
     token: () => tokenHolder.value,
     eventsHub: importHub,
@@ -1404,6 +1552,11 @@ function createServer(opts = {}) {
     pollMs: cfg.eventFeedClientPollMs,
   });
   eventFeedClient.start();
+  const importedDismissalDrainer = createImportedDismissalDrainer({
+    store: asksStore, relay: askRelay, readonly: proxyReadonly, log: opts.log || console.log,
+    bindingForOwner: dismissalBinding,
+  });
+
   // Local aggregated read for the UI: connected views only, with the cursor
   // watermark so the first fetch cannot race the live stream. Local
   // authenticated route, NOT in the federation allowlist.
@@ -1617,6 +1770,7 @@ function createServer(opts = {}) {
       });
       // Store-root revision of the peer access policy: the CAS value the UI
       // must send back with every preset write (stale revision -> 409).
+      importedDismissalDrainer.nudge();
       res.json({ nodeId: view.nodeId, nodes, accessRevision: nodesStore.accessRevisionOf(st) });
     } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
   });
@@ -1748,13 +1902,14 @@ function createServer(opts = {}) {
     diagnostics.record('info', 'server', 'SERVER_STARTED', 'NexusCrew server started', {
       port: runtimePort(), platform: cfg.platform || process.platform,
     });
-    updater.start(); startManagedTunnels();
+    updater.start(); startManagedTunnels(); importedDismissalDrainer.start();
   });
   server.on('close', () => {
     diagnostics.record('info', 'server', 'SERVER_STOPPED', 'NexusCrew server stopped', { reason: 'close' });
     watcher.close(); previews.close(); eventsHub.closeAll(); updater.close(); ptyGrace.close();
     // Nessun timer di ritentativo sopravvive alla chiusura del server.
     if (closureRetry) { try { closureRetry.stop(); } catch (_) {} }
+    importedDismissalDrainer.stop(); eventFeedClient.stop();
     for (const timer of reverseWatchers.values()) clearInterval(timer);
     reverseWatchers.clear(); rotatableReverse.clear(); void reverseSlotListeners?.closeAll();
     // Il pannello non sopravvive al control plane: senza requireToken sopra,

package/lib/tmux/list.js

@@ -108,6 +108,50 @@ function listSessions(tmuxBin = 'tmux') {
   });
 }
 
+// Il formato "fleet snapshot": i campi del supervisore di PANES_FMT (primi
+// quattro, gli stessi che legge parsePanes) SEGUITI dai campi della sessione.
+// UNA sola chiamata list-panes -a alimenta sia lo stato dei supervisori sia
+// l'inventario sessioni di /api/sessions: due spawn per giro diventano uno.
+// L'ordine dei campi sessione rispecchia FMT (name, attached, windows,
+// created, activity, cmd, visibility, titolo), con i due marker del pane
+// attivo prima del titolo.
+const FLEET_PANES_FMT = `${PANES_FMT}\t#{session_attached}\t#{session_windows}\t#{session_created}\t#{session_activity}\t#{pane_current_command}\t#{@nexuscrew_visibility}\t#{window_active}\t#{pane_active}\t#{pane_title}`;
+
+// Dalle righe per-pane alle righe per-SESSIONE: per ogni nome tiene il pane
+// ATTIVO (window_active=1 e pane_active=1) — lo stesso pane a cui si
+// riferivano i formati pane_* di list-sessions. I campi sessione sono uguali
+// su tutte le righe dello stesso nome; cambia solo quale pane parla, e deve
+// parlare quello attivo.
+function sessionsFromPanes(raw) {
+  const rows = new Map();
+  for (const line of String(raw).split('\n')) {
+    if (!line.trim()) continue;
+    const f = line.split('\t');
+    const name = f[0];
+    if (!name) continue;
+    const attiva = f[10] === '1' && f[11] === '1';
+    const previous = rows.get(name);
+    if (previous && (!attiva || previous.attiva)) continue;
+    rows.set(name, {
+      attiva,
+      line: [f[0], f[4], f[5], f[6], f[7], f[8], f[9], f.slice(12).join('\t')].join('\t'),
+    });
+  }
+  return parseSessions([...rows.values()].map((r) => r.line).join('\n'));
+}
+
+function listFleetPanes(tmuxBin = 'tmux') {
+  return new Promise((resolve, reject) => {
+    execFile(tmuxBin, ['list-panes', '-a', '-F', FLEET_PANES_FMT], (err, stdout, stderr) => {
+      if (err) {
+        if (isNoTmuxServerError(stderr || err.message)) return resolve('');
+        return reject(new Error(`tmux list-panes failed: ${stderr || err.message}`));
+      }
+      resolve(stdout);
+    });
+  });
+}
+
 // How many clients are already attached to this session (before our attach).
 // Used to pick a sane resize default: drive the size only when no one else is watching.
 function attachedClients(tmuxBin = 'tmux', session) {
@@ -123,4 +167,5 @@ function attachedClients(tmuxBin = 'tmux', session) {
 
 module.exports = {
   parsePaneTitle, parseSessions, isNoTmuxServerError, listSessions, listPanes, attachedClients, setSessionVisibility, FMT,
+  FLEET_PANES_FMT, sessionsFromPanes, listFleetPanes,
 };

package/lib/tmux-reads.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// Coalescing della risposta di /api/sessions (finestra di 2 s, decisione
+// operativa: latenza percepita al piu' pari alla finestra in cambio di spawn
+// dimezzati — anzi, di UNO spawn per finestra condiviso fra client).
+//
+// Tre comportamenti, tutti voluti:
+//  - letture entro la finestra servono la risposta gia' pronta: zero spawn;
+//  - letture che arrivano mentre il giro e' in volo aspettano QUELLO giro
+//    (mai due serie di spawn contemporanee per lo stesso endpoint);
+//  - un errore non si cache-a: il giro fallito non lascia nulla e la
+//    prossima lettura riparte da zero.
+//
+// La finestra e' breve PERCHE' la cache non deve nascondere i cambi di tmux:
+// kill, avvio e cambio finestra diventano visibili al piu' tardi al primo
+// giro dopo la finestra. Il test di freschezza custodisce esattamente questo.
+
+// Finestra di coalescing in millisecondi. Il valore e' un contratto
+// operativo (decisione approvata): al piu' 2 s di latenza aggiuntiva sulla
+// vista sessioni, in cambio di una serie sola di spawn per finestra.
+const TMUX_READS_WINDOW_MS = 2000;
+
+function createTmuxReadWindow(loader, windowMs = TMUX_READS_WINDOW_MS) {
+  let cached = null;
+  let inFlight = null;
+  return {
+    async read() {
+      if (cached && Date.now() - cached.at < windowMs) return cached.value;
+      if (inFlight) return inFlight;
+      inFlight = (async () => {
+        try {
+          const value = await loader();
+          cached = { at: Date.now(), value };
+          return value;
+        } finally {
+          inFlight = null;
+        }
+      })();
+      return inFlight;
+    },
+  };
+}
+
+module.exports = { TMUX_READS_WINDOW_MS, createTmuxReadWindow };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscrew",
-  "version": "0.9.58",
+  "version": "0.9.60",
   "description": "Faithful browser tmux client — attach to live sessions over a real PTY, localhost-only, mobile-easy",
   "main": "lib/server.js",
   "bin": {