@mmmbuto/nexuscrew 0.9.28 → 0.9.30

package/lib/live-host/bridge.js

@@ -1,27 +1,37 @@
 'use strict';
-// lib/live-host/bridge.js — il ponte Live (fetta 3, contratto rev5 + rev4 LC).
+// lib/live-host/bridge.js — the Live bridge (contract revision rev6 + rev4 LC).
 //
-// Esposizione: POST /api/live-host/bridge (montata in routes.js, stesso
-// requireToken e stessa policy local-only del proxy: LOCAL_ONLY_PREFIXES copre
-// l'intero prefisso /api/live-host, quindi nessun peer federato può innescare
-// il ponte). La chiamata rappresenta l'avvio di una Live sul nodo: chi la fa è
-// il lato app-server della stessa feature (non costruito qui), e il risultato
-// dice su che cosa quella Live va a operare.
+// Exposure: POST /api/live-host/bridge, mounted in routes.js. Reaching
+// /api/live-host directly stays a local-only path (LOCAL_ONLY_PREFIXES covers
+// the whole prefix), so a peer cannot knock on the bridge that way. A peer CAN
+// ask for it through the federated route /api/route/<nodes>/_/live-host/bridge:
+// that is the allowlisted path of the federation, the node that owns the cell
+// grants the per-peer permission (liveHostAccess, denied by default), and the
+// request carries the hop proof the server signs for the last hop. A federated
+// body may add one single field, `{expect}`: what the caller believes it is
+// pointing at, checked by the owner against its own saved designation — a
+// mismatch is a named 409.
+//
+// The resolution itself is unchanged: it is the SAVED designation, read where
+// it lives, so no caller picks a target, locally or across nodes. The call
+// represents starting a Live on the node: the app-server side of the same
+// feature makes it (not built here), and the answer says what that Live is
+// going to operate on.
 //
 // Invarianti (contratto fetta 3):
-//   - MC1: la designazione si legge con UNA GET su loopback verso
+// La designazione si legge con UNA GET su loopback verso
 //     /api/live-host, autenticata col token del nodo. Nessun accesso diretto
 //     allo store: la route è l'unica verità, `eligible` non si ricalcola.
-//   - MC1.5 / JC3.3: nessuna attesa introdotta. Ogni fase ha il limite
+// Nessuna attesa introdotta. Ogni fase ha il limite
 //     dichiarato cfg.liveBridgeTimeoutMs; oltre quello, o su qualunque
 //     fallimento, la risposta è `none` col motivo: la Live parte senza
 //     puntamento, comportamento standard. Un `none` non è un errore HTTP.
-//   - MC2: il prompt per-cella (LIVE_PROMPT.md accanto ai canonici della
+// Il prompt per-cella (LIVE_PROMPT.md accanto ai canonici della
 //     cella) viaggia su developerInstructions di thread/start e SOSTITUISCE
-//     le developer instructions della config per quella Live (rev4 LC2
-//     emendata da rev5 MC2). La riga che decide è in codex-rs
+// Le developer instructions della config per quella Live (rev4
+// Emendata da rev5). La riga che decide è in codex-rs
 //     core/src/config/mod.rs: `developer_instructions.or(cfg.developer_
-//     instructions)` — l'override Some scarta il valore di config. R2
+// Instructions)` — l'override Some scarta il valore di config.
 //     (verso corretto dopo revisione pre-release): l'identità della
 //     cella designata viaggia SEMPRE come intestazione anteposta al campo,
 //     anche senza prompt. Il campo NON è additivo: una cella senza
@@ -31,18 +41,18 @@
 //     il world state (fragment user, canale separato) e il prompt base.
 //     La via designata per le istruzioni di lavoro della Live è il
 //     LIVE_PROMPT.md della cella: viaggia nello stesso campo.
-//   - MC3: il ponte crea le proprie conversazioni con thread/start e non
+// Il ponte crea le proprie conversazioni con thread/start e non
 //     tocca MAI la thread di una TUI — né turn/start né thread/resume. La sonda
 //     thread/read e' separata e sola lettura: non modifica il thread ponte ne'
 //     quello della TUI. Per questo l'aggancio funziona anche su una cella che
 //     sta già processando un turno: conversazioni separate, nessuna
-//     interruzione (rev1 HC2/rev2 JC4).
-//   - MC3.3: la connessione al socket di controllo è ON-DEMAND (connect →
+// Interruzione (rev1 /rev2).
+// La connessione al socket di controllo è ON-DEMAND (connect →
 //     handshake → thread/start → close), mai permanente: la fuga notifiche
 //     notata in rev5 riguarda i client permanenti.
-//   - MC3.4: il ponte opera SOLO sulla cella designata — non accetta target
-//     dal chiamante, la designazione è la condizione (LC3).
-//   - MC0: isolabile — cfg.liveBridgeEnabled=false e il ponte non si connette
+// Il ponte opera SOLO sulla cella designata — non accetta target
+// Dal chiamante, la designazione è la condizione.
+// Isolabile — cfg.liveBridgeEnabled=false e il ponte non si connette
 //     mai, non fa GET, risponde `none` senza toccare nulla.
 //
 // Protocollo del socket di controllo (misurato sul runtime 2026-08-15):
@@ -51,7 +61,7 @@
 // (senza params). Poi `thread/start` {cwd, developerInstructions?} → response
 // {thread:{id}, cwd}, oppure `thread/read` {threadId, includeTurns:false} per
 // leggere il runtime. Il socket è 0600 dell'utente: il confine è quello
-// (MC1.3), non c'è autenticazione applicativa.
+// Non c'è autenticazione applicativa.
 
 const fs = require('node:fs');
 const path = require('node:path');
@@ -164,10 +174,10 @@ function queryThreadStatusOnControlSocket({
   });
 }
 
-// —— Prompt per-cella (rev4 LC2, nome fisso confermato il 2026-08-15) ——
+// — Prompt per-cella (rev4, nome fisso confermato il 2026-08-15) ——
 // Collocazione: filesRoot/<tmuxSession>/LIVE_PROMPT.md — la sessione tmux
 // ESATTA che il roster dichiara per la cella designata, la stessa fonte gia'
-// usata per l'intestazione R2 (identityHeader). NON un prefisso ricostruito a
+// Usata per l'intestazione (identityHeader). NON un prefisso ricostruito a
 // mano: fino al 2026-08-16 questa funzione anteponeva 'cloud-' come default
 // universale quando il cellId non ce l'aveva gia' — su un device che chiama
 // le proprie sessioni con un prefisso diverso il file non veniva MAI trovato,
@@ -184,8 +194,8 @@ function queryThreadStatusOnControlSocket({
 //                                   costruito (mai un prefisso indovinato),
 //                                   quindi non si tenta nemmeno la lettura
 //   applied:false, reason missing       → ENOENT sul path dichiarato: assenza
-//                                   legittima (LC2.3), si procede senza
-//                                   PROMPT (R2: l'intestazione identità
+// Legittima, si procede senza
+// PROMPT: the identity header
 //                                   viaggia comunque). ATTENZIONE: il campo
 //                                   developerInstructions viene comunque
 //                                   inviato per via dell'intestazione, e il
@@ -193,7 +203,7 @@ function queryThreadStatusOnControlSocket({
 //                                   configurazione invece di sommarlo — chi
 //                                   non ha prompt per-cella non riceve le
 //                                   developer instructions globali che
-//                                   riceveva prima (vedi MC2, verificato
+// Riceveva prima (verificato
 //                                   sulla riga che decide)
 //   applied:false, reason unreadable|empty → presente ma inutilizzabile: va
 //                                   dichiarato, mai silenziato
@@ -212,14 +222,14 @@ function readCellPrompt(filesRoot, tmuxSession) {
   return { applied: true, source: 'LIVE_PROMPT.md', text };
 }
 
-// —— Identità della Live (R2, 2026-08-16): la porta il ponte, non il prompt ——
-// Il ponte ha la designazione IN MANO (MC3.4: è la sua condizione di
-// funzionamento) e un prompt può legittimamente mancare (MC2.4): se
+// — Identità della Live (2026-08-16): la porta il ponte, non il prompt ——
+// Il ponte ha la designazione IN MANO: è la sua condizione di
+// Funzionamento) e un prompt può legittimamente mancare: se
 // l'identità dipendesse dal prompt, l'assenza del prompt diventerebbe assenza
 // di identità — è esattamente il difetto visto sul campo (la voce andava a
 // leggere tmux per capire dove si trovava).
 //
-// R30 (v2, 2026-08-19): l'intestazione dice anche COME raggiungere i tool
+// (v2, 2026-08-19): the header also states HOW to reach the tools
 // NexusCrew. Il daemon app-server espone UN solo insieme di server MCP a
 // tutte le Live, con l'ambiente del daemon: nexuscrew è l'unico che prende
 // l'identità dall'ambiente ereditato, quindi i suoi tool con sessione
@@ -343,7 +353,7 @@ function startThreadOnControlSocket({
             title: 'NexusCrew Live Bridge',
             version: bridgeVersion(),
             // Identita della connessione: la sessione gia' risolta della cella
-            // designata (mai env grezzi, mai guess — roster MC3.4). Se assente
+            // Designata (mai env grezzi, mai guess — roster). Se assente
             // il campo SI OMETTE (Option None lato protocollo): il resolver a
             // valle classifica MISSING nominando la causa; sanitizzare qui la
             // duplicherebbe senza guadagno.
@@ -390,7 +400,7 @@ function startThreadOnControlSocket({
         return;
       }
       // Notifiche broadcast e risposte non attese: ignorate (connessione
-      // on-demand, la finestra di esposizione alla fuga MC3.3 è minima).
+      // On-demand, la finestra di esposizione alla fuga è minima).
     });
 
     ws.on('error', (e) => done(Object.assign(new Error(`control socket: ${e.message}`), { code: 'ESOCKET' })));
@@ -416,7 +426,7 @@ function createLiveBridge({
   const threadIdsByCell = new Map();
   const threadStatusCache = new Map();
   const threadStatusInFlight = new Map();
-  // R4: riserve in-process per l'avvio Live. La chiave è la cella host: una
+  // Riserve in-process per l'avvio Live. La chiave è la cella host: una
   // sola start provvisoria per cella alla volta, e il commit ricontrolla la
   // tupla congelata in riserva prima di accettare il thread creato.
   const pendingLiveByCell = new Map();
@@ -425,7 +435,7 @@ function createLiveBridge({
 
   const none = (reason, extra) => ({ mode: 'none', reason, ...(extra || {}), at: now() });
 
-  // MC1: la designazione si legge dalla ROUTE, con il token del nodo, entro
+  // La designazione si legge dalla ROUTE, con il token del nodo, entro
   // il limite dichiarato. retry no, cache no: una lettura per avvio Live.
   async function readDesignation() {
     const ctrl = new AbortController();
@@ -543,7 +553,7 @@ function createLiveBridge({
     if (cell.active !== true) return none('host-cell-inactive');
     if (typeof cell.cwd !== 'string' || !cell.cwd) return none('cell-cwd-unknown');
 
-    // JC2: la modalità è una funzione dell'engine, non una scelta. Nativa solo
+    // La modalità è una funzione dell'engine, non una scelta. Nativa solo
     // su engine codex-vl (il thread ponte vive nell'app-server del fork); per
     // qualunque altro engine la Live lavora ATTRAVERSO la cella e il ponte non
     // ha nulla da creare qui.
@@ -555,7 +565,7 @@ function createLiveBridge({
     if (!engine.startsWith('codex-vl')) {
       const out = {
         mode: 'tmux', cell: snap.hostCell, engine: cell.engine || null, cwd: cell.cwd,
-        // JC5.5: in modalità tmux le regole le applica la cella; nessuna
+        // In modalità tmux le regole le applica la cella; nessuna
         // iniezione da parte del ponte.
         prompt: { applied: false, reason: 'tmux-mode' },
         at: now(),
@@ -564,16 +574,16 @@ function createLiveBridge({
       return out;
     }
 
-    // R2: l'identità viaggia SEMPRE, anteposta al prompt quando c'è. Il campo
+    // L'identità viaggia SEMPRE, anteposta al prompt quando c'è. Il campo
     // non è mai più assente: senza LIVE_PROMPT.md porta la sola intestazione
     // — e poiché il campo SOSTITUISCE le developer instructions della config
-    // (vedi MC2: la .or() in config/mod.rs), quella cella non le riceve più.
+// (see: the .or() in config/mod.rs), that cell no longer receives them.
     const intestazione = identityHeader(snap.hostCell, cell.tmuxSession);
     const developerInstructions = prompt.applied
       ? `${intestazione}\n\n${prompt.text}`
       : intestazione;
 
-    // R4: riserva della tupla e start provvisorio. Finché il commit non
+    // Riserva della tupla e start provvisorio. Finché il commit non
     // ricontrolla la stessa tupla, il thread NON viene accettato: nessun tool
     // può attraversarlo, perché il ponte non ne registra l'id.
     if (pendingLiveByCell.has(snap.hostCell)) return none('reservation-in-flight');
@@ -588,8 +598,8 @@ function createLiveBridge({
         cwd: cell.cwd,
         developerInstructions,
         // Stessa fonte dell'intestazione e del prompt per-cella (roster:
-        // MC3.4). Dichiarata per connessione: batte qualunque ambiente
-        // ereditato, anche quando e' popolato ma stantio (B1-bis).
+        //). Dichiarata per connessione: batte qualunque ambiente
+        // Ereditato, anche quando e' popolato ma stantio (-bis).
         declaredSession: cell.tmuxSession,
         timeoutMs: cfg.liveBridgeTimeoutMs,
         WebSocket,
@@ -602,7 +612,7 @@ function createLiveBridge({
       return none(reason, { cell: snap.hostCell, detail: String(e.message) });
     }
 
-    // R4: commit. La designazione e il lease vengono riletti e confrontati con
+    // Commit. La designazione e il lease vengono riletti e confrontati con
     // la tupla riservata: se qualcosa è cambiato durante lo start, il thread
     // resta scartato (zero dispatch) e l'esito lo dichiara con l'id scartato.
     let commitSnap;
@@ -639,9 +649,9 @@ function createLiveBridge({
     };
     threadIdsByCell.set(snap.hostCell, started.threadId);
     threadStatusCache.delete(snap.hostCell);
-    // LC1.4: il puntamento è visibile lato nostro — log con cella, thread e
+    // Il puntamento è visibile lato nostro — log con cella, thread e
     // prompt applicato. È il "dirottamento dichiarato" del contratto. Il
-    // campo SOSTITUISCE le developer instructions della config (MC2, la
+    // Campo SOSTITUISCE le developer instructions della config (la
     // .or() in config/mod.rs): il log lo dichiara, perché chi lo legge sappia
     // cosa quella Live NON riceve.
     log(`[live-bridge] Live puntata su ${snap.hostCell}: thread ${started.threadId} (cwd ${started.cwd}, identità nell'intestazione, prompt ${prompt.applied ? 'per-cella applicato' : `non applicato (${promptEcho.reason})`}, sostituisce le developer instructions di config)`);

package/lib/live-host/federation.js

@@ -0,0 +1,97 @@
+'use strict';
+// lib/live-host/federation.js — client-side seam per la designazione remota.
+//
+// Un nodo CLIENT (la pagina e il ponte vivono qui, la cella designata no) deve
+// poter LEGGERE lo stato del proprietario e INOLTRARE la risoluzione del ponte,
+// senza che nessun chiamante scelga il target: il target e' il proprietario
+// della designazione registrata, risolto sulla topologia autoritativa (stessa
+// regola del dispatcher audio/notify). Nessun fallback locale: se il
+// proprietario non e' raggiungibile l'esito e' nominato, non sostituito.
+//
+// Il transito usa la stessa via di tutti: /api/route/<route>/_<resource> col
+// Bearer locale — il primo hop e' questo stesso server, che applica peering,
+// gate liveHostAccess e prova di hop come per qualunque altro inoltro.
+const { resolvePeer } = require('../nodes/inventory.js');
+
+const INSTANCE_ID_RE = /^[a-f0-9]{32}$/i;
+// Refusal names the owner may send back. The caller must not relabel "not
+// granted" as "unreachable": a refusal is a decision, an unreachable peer is a
+// failure. Anything outside this list stays unnamed, not guessed.
+const NAMED_PEER_REASONS = new Set(['live-host-not-granted', 'live-host-expectation-mismatch']);
+// Name THIS node's own proxy gives to "I could not reach the peer": from here it
+// means the owner is unreachable, not that the owner refused.
+const PEER_UNREACHABLE = 'federation-peer-unreachable';
+const FED_TIMEOUT_MS = 8000;
+
+function createLiveHostFederation({
+  localNodeId = () => null,
+  peers = async () => [],
+  localPort = () => 0,
+  localToken = () => '',
+  fetchImpl = fetch,
+  timeoutMs = FED_TIMEOUT_MS,
+} = {}) {
+  async function resolveRoute(target) {
+    if (!INSTANCE_ID_RE.test(String(target || ''))) return { error: 'invalid-target' };
+    let list;
+    try { list = await peers(); } catch (_) { return { error: 'topology-unavailable' }; }
+    if (!Array.isArray(list) || !list.length) return { error: 'unknown-target' };
+    const found = resolvePeer(list.filter((p) => p && (p.nodeId || p.instanceId)), String(target));
+    if (found.error || !found.peer) return { error: 'unknown-target' };
+    const route = Array.isArray(found.peer.route) ? found.peer.route.filter(Boolean) : [];
+    if (!route.length) return { error: 'unknown-target' };
+    return { route, peer: found.peer };
+  }
+
+  function ownerRoute(target) {
+    return resolveRoute(target).then((r) => (r.route ? r.route : null)).catch(() => null);
+  }
+
+  async function forward(target, resource, method, body) {
+    const resolved = await resolveRoute(target);
+    if (resolved.error) return { ok: false, reason: resolved.error === 'invalid-target' ? 'invalid-target' : 'live-host-owner-unreachable' };
+    const port = localPort();
+    const token = localToken();
+    if (!port || !token) return { ok: false, reason: 'live-host-owner-unreachable' };
+    const url = `http://127.0.0.1:${port}/api/route/${resolved.route.join('/')}/_${resource}`;
+    let res;
+    try {
+      res = await fetchImpl(url, {
+        method,
+        headers: { authorization: `Bearer ${token}`, ...(body !== undefined ? { 'content-type': 'application/json' } : {}) },
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+        signal: AbortSignal.timeout(timeoutMs),
+      });
+    } catch (_) {
+      return { ok: false, reason: 'live-host-owner-unreachable' };
+    }
+    let payload = null;
+    try { payload = await res.json(); } catch (_) { payload = null; }
+    const named = payload && NAMED_PEER_REASONS.has(payload.reason) ? payload.reason : null;
+    const ok = res.status >= 200 && res.status < 300;
+    // A refusal we can name stays the owner's own word for it; our own proxy's
+    // "peer unreachable" means the owner is unreachable; anything else the owner
+    // answers with comes back under OUR generic name plus the status we saw — a
+    // peer string is never passed on as if we had checked it.
+    const reason = ok ? null
+      : (payload && payload.reason === PEER_UNREACHABLE ? 'live-host-owner-unreachable'
+        : (named || 'live-host-owner-rejected'));
+    return { ok, status: res.status, body: payload, route: resolved.route, ...(reason ? { reason } : {}) };
+  }
+
+  // Stato del proprietario per la GET locale (threadStatus/eligible/lease).
+  function getOwnerState({ ownerId } = {}) {
+    return forward(ownerId, '/live-host', 'GET');
+  }
+
+  // Inoltro della risoluzione del ponte. Il body e' SOLO `{expect}` (unico
+  // campo ammesso dal percorso federato): coincide con la designazione
+  // registrata localmente, quindi il chiamante non sceglie nulla.
+  function bridgeForward({ ownerId, expect } = {}) {
+    return forward(ownerId, '/live-host/bridge', 'POST', { expect });
+  }
+
+  return { getOwnerState, bridgeForward, ownerRoute };
+}
+
+module.exports = { createLiveHostFederation };

package/lib/live-host/routes.js

@@ -10,7 +10,7 @@
 // chiede. Senza quel permesso il peer riceve un rifiuto che nomina la causa
 // (`live-host-not-granted`), non un silenzio.
 //
-// Invarianti (contratto rev6 §2, §9):
+// Invariants (host-cell designation contract):
 //   - hostCell unico per nodo, CAS su revision (due designazioni concorrenti non
 //     lasciano due celle rosse).
 //   - API-first: la route e' l'unica autorita'; il frontend riflette la risposta e
@@ -26,6 +26,14 @@
 
 const express = require('express');
 const { CELL_ID_RE } = require('./store.js');
+const { HOP_HEADER } = require('../proxy/hop-proof.js');
+
+// Il ponte federato non nasce da una cella: nasce dal nodo che ospita la
+// pagina/app-server. L'identita' che si puo' PROVARE e' quindi il nodo, e il
+// budget si conta per nodo mittente; questa costante tiene il posto della cella
+// nella chiave (v. lib/audio/rate-limit.js: originKey vuole {node, cell}) e vale
+// anche come nome del target quando il nodo non ha una designazione da nominare.
+const LIVE_HOST_BUCKET = 'live-host';
 
 // Ricava l'elenco celle LOCALI dal fleet (definizioni, attive e non). Una cella
 // federata non compare qui: e' il check che chiude "designa solo una cella di questo
@@ -76,9 +84,40 @@ function eligibleOf(fleet, cell, hostCell) {
   return isActive(cell) && leaseState === 'live';
 }
 
-function liveHostRoutes({ fleetP, store, readonly = () => false, now = () => Date.now(), bridge = null }) {
+function liveHostRoutes({ fleetP, store, readonly = () => false, now = () => Date.now(), bridge = null,
+  // Federazione della designazione remota. `federation` (client seam:
+  // getOwnerState/bridgeForward/ownerRoute) e' presente solo sul nodo CLIENT;
+  // `originResolver` + `federatedRate` attivano la via federata DEL PROPRIETARIO:
+  // una richiesta con prova di hop puo' portare `{expect}` (unico campo) e deve
+  // coincidere con la designazione locale, altrimenti 409 nominato. Assenti
+  // (test parziali) le route restano esattamente quelle locali di prima.
+  // Sul ramo federato l'origine NON e' un campo del body: e' il risultato di una
+  // verifica (prova di hop + catena `visited` costruita dal server), e il budget
+  // del ponte si applica per NODO mittente ATTESTATO — stessa regola e stessi
+  // limiti dell'audio (lib/audio/rate-limit.js).
+  federation = null, originResolver = null, federatedRate = null }) {
   const r = express.Router();
 
+  // Una designazione con `ownerId` e' REMOTA: il puntamento vive qui,
+  // la verita' (thread/eligible/lease) vive sul proprietario. Lo stato del
+  // proprietario arriva via GET federata; irraggiungibile => threadStatus
+  // 'unknown' con reason NOMINATO, mai un fallback su una cella locale.
+  async function remoteOwnerState(snap) {
+    if (!federation || typeof federation.getOwnerState !== 'function') {
+      return { reason: 'live-host-federation-unavailable' };
+    }
+    const out = await federation.getOwnerState({ ownerId: snap.ownerId }).catch(() => ({ ok: false, reason: 'live-host-owner-unreachable' }));
+    if (!out || out.ok !== true || !out.body) return { reason: 'live-host-owner-unreachable' };
+    const b = out.body;
+    return {
+      state: {
+        eligible: b.eligible === true,
+        threadStatus: b.threadStatus || 'unknown',
+        host: b.host || null,
+      },
+    };
+  }
+
   // GET /api/live-host — { hostCell, revision, eligible, threadStatus,
   // host: {lease}, at }. threadStatus misura il runtime del thread ponte:
   // absent/present/active/unknown; non dichiara la presenza del client Live.
@@ -88,6 +127,17 @@ function liveHostRoutes({ fleetP, store, readonly = () => false, now = () => Dat
   r.get('/', async (_req, res) => {
     try {
       const snap = store.snapshot();
+      if (snap.hostCell != null && snap.ownerId) {
+        const remote = await remoteOwnerState(snap);
+        return res.json({
+          hostCell: snap.hostCell, revision: snap.revision, ownerId: snap.ownerId, remote: true,
+          eligible: remote.state ? remote.state.eligible : false,
+          threadStatus: remote.state ? remote.state.threadStatus : 'unknown',
+          host: remote.state ? remote.state.host : null,
+          ...(remote.reason ? { reason: remote.reason } : {}),
+          at: now(),
+        });
+      }
       let eligible = false;
       let lease = null;
       let threadStatus = 'absent';
@@ -164,13 +214,121 @@ function liveHostRoutes({ fleetP, store, readonly = () => false, now = () => Dat
   });
 
   // POST /api/live-host/bridge — risolve il puntamento per l'avvio di una Live
-  // (fetta 3). La richiesta NON è parametrizzabile: la designazione è la
-  // condizione (LC3) e nessun chiamante può scegliere il target (MC3.4). Il
-  // ponte risponde sempre 200: i `none` con reason sono esiti legittimi e
-  // distinti (nessuna designazione / cella non idonea / fallback), non errori.
-  // Body opzionale e vuoto: un body con campi è un 400, non viene ignorato.
+  // (fetta 3). La richiesta NON è parametrizzabile dal chiamante: la
+  // designazione è la condizione, e nessun chiamante sceglie il target — ma la
+  // designazione ora può puntare FUORI nodo, e in
+  // quel caso questo nodo (client) INOLTRA la risoluzione al proprietario
+  // (stessa richiesta, senza parametri di scelta; `expect` è l'attestazione di
+  // cosa il client sta puntando, verificata dal proprietario). Il ponte
+  // risponde sempre 200: i `none` con reason sono esiti legittimi e distinti
+  // (nessuna designazione / cella non idonea / fallback), non errori.
+  // Body opzionale e vuoto: un body con campi è un 400, non viene ignorato —
+  // eccezione: sul PERCORSO FEDERATO (prova di hop) il proprietario accetta
+  // `{expect:{hostCell,revision}}` e lo verifica contro la propria
+  // designazione (mismatch = 409 nominato); il gate `liveHostAccess` del peer
+  // è già stato applicato dall'ingresso federato (federation.js).
   r.post('/bridge', express.json({ limit: '1kb' }), async (req, res) => {
     const body = req.body || {};
+    const federated = !!(originResolver && req.headers && req.headers[HOP_HEADER]);
+    if (federated) {
+      const keys = Object.keys(body);
+      if (keys.length > 1 || (keys.length === 1 && keys[0] !== 'expect')) {
+        return res.status(400).json({ error: 'la risoluzione non accetta parametri' });
+      }
+      // Budget federato. L'origine la da' l'originResolver, che verifica la prova
+      // di hop e la catena controllata dal server: la stringa `visited` letta a
+      // mano non e' un'attribuzione, e un limiter interrogato con la forma
+      // sbagliata (`allow` invece di `check`) non limita nulla — era il difetto.
+      // Una richiesta la cui origine non e' verificabile viene rifiutata qui,
+      // non servita senza budget: fail-closed, mai un limite saltato in silenzio.
+      if (federatedRate) {
+        const resolved = typeof originResolver.resolve === 'function'
+          ? await originResolver.resolve(req, { requireCell: false })
+          : { ok: false, reason: 'no-origin-resolver' };
+        if (!resolved || resolved.ok !== true) {
+          return res.status(403).json({
+            error: 'origine federata non verificabile', reason: 'live-host-origin-unverified',
+            detail: (resolved && resolved.reason) || 'unknown',
+          });
+        }
+        const quota = federatedRate.check({
+          origin: { node: resolved.origin.node, cell: LIVE_HOST_BUCKET },
+          target: store.snapshot().hostCell || LIVE_HOST_BUCKET,
+          urgency: 'normal',
+        });
+        if (!quota.allowed) {
+          return res.status(429).json({
+            error: 'troppo frequente', reason: 'rate-limited',
+            bucket: quota.bucket, retryInMs: quota.retryInMs,
+          });
+        }
+      }
+      const snap = store.snapshot();
+      if (keys.length === 1) {
+        const expect = body.expect || {};
+        const okExpect = expect && typeof expect.hostCell === 'string'
+          && Number.isInteger(expect.revision)
+          && expect.hostCell === snap.hostCell && expect.revision === snap.revision;
+        if (!okExpect) {
+          return res.status(409).json({
+            error: 'la designazione del proprietario non coincide con quella dichiarata dal client',
+            reason: 'live-host-expectation-mismatch',
+            revision: snap.revision, hostCell: snap.hostCell, at: now(),
+          });
+        }
+      }
+      if (readonly()) return res.json({ mode: 'none', reason: 'readonly', at: now() });
+      if (!bridge) return res.status(503).json({ error: 'ponte Live non configurato su questo nodo' });
+      try {
+        const result = await bridge.resolveForLive();
+        res.json(result);
+      } catch (e) {
+        res.json({ mode: 'none', reason: 'bridge-error', detail: String(e && e.message || e), at: now() });
+      }
+      return;
+    }
+    const snap = store.snapshot();
+    if (snap.hostCell != null && snap.ownerId) {
+      // Nodo CLIENT con host remoto: inoltra al proprietario, mai un
+      // fallback su una cella locale (il chiamante non sceglie il target: lo
+      // sceglie la designazione, che punta fuori nodo).
+      if (!federation || typeof federation.bridgeForward !== 'function') {
+        return res.status(503).json({ mode: 'none', reason: 'live-host-federation-unavailable', at: now() });
+      }
+      const out = await federation.bridgeForward({
+        ownerId: snap.ownerId,
+        expect: { hostCell: snap.hostCell, revision: snap.revision },
+      }).catch(() => ({ ok: false, reason: 'live-host-owner-unreachable' }));
+      if (!out) {
+        return res.status(502).json({ mode: 'none', reason: 'live-host-owner-unreachable', at: now() });
+      }
+      // The owner's DECIDABLE answers come first: a refusal and a moved
+      // designation are decisions, not failures. Flattening them into
+      // "unreachable" would hide exactly what the operator has to fix.
+      if (out.status === 403 || out.reason === 'live-host-not-granted') {
+        return res.status(403).json({ mode: 'none', reason: 'live-host-not-granted', at: now() });
+      }
+      if (out.status === 409 || out.reason === 'live-host-expectation-mismatch') {
+        return res.status(409).json({
+          error: 'la designazione del proprietario non coincide con quella dichiarata dal client',
+          reason: 'live-host-expectation-mismatch', at: now(),
+        });
+      }
+      if (out.ok !== true) {
+        // Whatever else the owner answered: our own name plus the status we saw,
+        // never a peer string we did not check — and never "unreachable" for a
+        // node that did answer.
+        const reason = out.reason === 'live-host-owner-unreachable' ? 'live-host-owner-unreachable' : 'live-host-owner-rejected';
+        return res.status(502).json({
+          mode: 'none', reason,
+          ...(Number.isInteger(out.status) ? { ownerStatus: out.status } : {}), at: now(),
+        });
+      }
+      const ownerBody = out.body || { mode: 'none', reason: 'bridge-error' };
+      const route = federation.ownerRoute
+        ? await federation.ownerRoute(snap.ownerId).catch(() => null) : null;
+      return res.json({ ...ownerBody, owner: snap.ownerId, ...(Array.isArray(route) && route.length ? { route } : {}), at: now() });
+    }
     if (Object.keys(body).length > 0) return res.status(400).json({ error: 'la risoluzione non accetta parametri' });
     if (readonly()) return res.json({ mode: 'none', reason: 'readonly', at: now() });
     if (!bridge) return res.status(503).json({ error: 'ponte Live non configurato su questo nodo' });
@@ -178,7 +336,7 @@ function liveHostRoutes({ fleetP, store, readonly = () => false, now = () => Dat
       const result = await bridge.resolveForLive();
       res.json(result);
     } catch (e) {
-      // Il contratto (MC1.5) vuole che un guasto del ponte non fermi la Live:
+      // Il contratto vuole che un guasto del ponte non fermi la Live:
       // anche l'inaspettato collassa in `none` dichiarato, mai un 500.
       // `bridge-error` e' l'ultima rete: un'eccezione che nessun ramo previsto ha
       // classificato. Va NOMINATA come le altre, non lasciata fuori dall'elenco

package/lib/live-host/store.js

@@ -1,10 +1,10 @@
 'use strict';
 // lib/live-host/store.js — stato della designazione "cella ospite Live" di un nodo.
 //
-// Un solo hostCell per nodo (contratto rev6 §2.2): chiave unica, non una convenzione
-// ripetuta in N punti. Lo stato vive su disco (sopravvive a riavvii di cella e di
-// NexusCrew) e l'aggiornamento e' un CAS su `revision`: due designazioni concorrenti
-// non possono lasciare due celle rosse — il perdente rilegge la revision e rinuncia.
+// One hostCell per node (unique key, not a repeated convention):
+// the state lives on disk (survives cell and NexusCrew restarts) and the
+// update is a CAS on `revision`: two concurrent designations cannot leave
+// two red cells — the loser re-reads the revision and gives up.
 //
 // La designazione e' PURAMENTE un marker di scelta del nodo. L'eligibilita' (la cella
 // e' anche attiva in questo momento?) e' derivata dal roster Fleet e non si persiste
@@ -17,6 +17,7 @@ const os = require('node:os');
 const { readJsonSafe, atomicWriteJson } = require('../notify/persist.js');
 
 const CELL_ID_RE = /^[A-Za-z0-9._-]{1,32}$/;
+const NODE_ID_RE = /^[a-f0-9]{32}$/i;
 
 // Path del file di stato: override esplicito -> dir del token (~/.nexuscrew) -> home.
 // Stessa convenzione di consentPath/groupsPath, cosi' i test isolano lo stato via
@@ -34,7 +35,13 @@ function normalize(raw) {
   const revision = raw && Number.isInteger(raw.revision) && raw.revision >= 0 ? raw.revision : 0;
   const hostCell = raw && typeof raw.hostCell === 'string' && CELL_ID_RE.test(raw.hostCell)
     ? raw.hostCell : null;
-  return { revision, hostCell };
+  // La designazione puo' puntare a una cella di un ALTRO nodo. `ownerId`
+  // assente/null = cella locale (comportamento storico); presente = puntamento
+  // remoto: `revision` e' quella del PROPRIETARIO (il client non la avanza,
+  // rispecchia lo stato di chi possiede la cella).
+  const ownerId = raw && typeof raw.ownerId === 'string' && NODE_ID_RE.test(raw.ownerId)
+    ? raw.ownerId.toLowerCase() : null;
+  return { revision, hostCell, ownerId };
 }
 
 function readLiveHost(filePath) {
@@ -90,7 +97,38 @@ function createLiveHostStore({ filePath, now = () => Date.now() } = {}) {
     });
   }
 
-  return { snapshot, compareAndSet, filePath };
+  // Registra/rispecchia il puntamento remoto dopo che il PROPRIETARIO ha
+  // accettato la designazione (via federata). Nessun CAS locale: la revision
+  // e' quella del proprietario, il client la rispecchia.
+  function setRemoteDesignation({ ownerId, hostCell, revision }) {
+    return serialize(() => {
+      if (!NODE_ID_RE.test(String(ownerId || ''))) {
+        return { ok: false, conflict: true, revision: 0, hostCell: null };
+      }
+      const cell = typeof hostCell === 'string' && CELL_ID_RE.test(hostCell) ? hostCell : null;
+      const rev = Number.isInteger(revision) && revision >= 0 ? revision : 0;
+      const revised = { revision: rev, hostCell: cell, ownerId: cell == null ? null : ownerId.toLowerCase(), updatedAt: now() };
+      atomicWriteJson(filePath, revised);
+      return { ok: true, revision: revised.revision, hostCell: revised.hostCell, ownerId: revised.ownerId, at: revised.updatedAt };
+    });
+  }
+
+  // Cancella il puntamento remoto SOLO se appartiene a quel proprietario
+  // (una designazione locale non toccata da un clear federato altrui).
+  function clearForOwner(ownerId) {
+    return serialize(() => {
+      const cur = readLiveHost(filePath);
+      if (cur.ownerId && NODE_ID_RE.test(String(ownerId || '')) && cur.ownerId !== String(ownerId).toLowerCase()) {
+        return { ok: false, revision: cur.revision, hostCell: cur.hostCell, ownerId: cur.ownerId };
+      }
+      if (!cur.ownerId) return { ok: true, revision: cur.revision, hostCell: cur.hostCell, ownerId: null };
+      const revised = { revision: 0, hostCell: null, updatedAt: now() };
+      atomicWriteJson(filePath, revised);
+      return { ok: true, revision: 0, hostCell: null, ownerId: null, at: revised.updatedAt };
+    });
+  }
+
+  return { snapshot, compareAndSet, setRemoteDesignation, clearForOwner, filePath };
 }
 
 module.exports = { createLiveHostStore, liveHostPath, readLiveHost, normalize, CELL_ID_RE };