npm - @mmmbuto/nexuscrew - Versions diffs - 0.8.46 → 0.8.48 - Mend

@mmmbuto/nexuscrew 0.8.46 → 0.8.48

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/CHANGELOG.md +86 -0
package/frontend/dist/assets/{index-BAq6N1Md.css → index-43DFO1EH.css} +1 -1
package/frontend/dist/assets/index-C_SyIZ78.js +93 -0
package/frontend/dist/index.html +2 -2
package/frontend/dist/version.json +1 -1
package/lib/cells/routes.js +18 -1
package/lib/fleet/builtin.js +7 -1
package/lib/fleet/cell-exec.js +126 -18
package/lib/fleet/definitions.js +16 -0
package/lib/fleet/launch.js +80 -23
package/lib/fleet/managed.js +10 -2
package/lib/fleet/prompt-delivery.js +275 -0
package/lib/fleet/runtime.js +52 -11
package/lib/mcp/cells.js +11 -0
package/lib/mcp/tools.js +1 -1
package/lib/nodes/inventory.js +5 -0
package/lib/nodes/reverse-rotation.js +22 -1
package/lib/nodes/reverse-slot-listeners.js +10 -1
package/lib/nodes/reverse-slot-proof.js +10 -0
package/lib/nodes/topology-cache.js +11 -2
package/lib/proxy/federation.js +98 -10
package/lib/server.js +27 -7
package/lib/settings/routes.js +58 -5
package/lib/ws/bridge.js +26 -2
package/package.json +1 -1
package/frontend/dist/assets/index-DMG-rioF.js +0 -93

package/frontend/dist/index.html CHANGED Viewed

@@ -11,8 +11,8 @@
   <meta name="apple-mobile-web-app-title" content="NexusCrew" />
   <link rel="manifest" href="/manifest.json" />
   <title>NexusCrew</title>
-  <script type="module" crossorigin src="/assets/index-DMG-rioF.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-BAq6N1Md.css">
+  <script type="module" crossorigin src="/assets/index-C_SyIZ78.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-43DFO1EH.css">
 </head>
 <body>
   <div id="root"></div>

package/frontend/dist/version.json CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":"0.8.46"}
1	+ {"version":"0.8.48"}

package/lib/cells/routes.js CHANGED Viewed

@@ -5,6 +5,19 @@ const { isValidSession } = require('../files/store.js');
 const { submitTextOk } = require('../tmux/actions.js');
 const CELL_ID_RE = /^[A-Za-z0-9._-]{1,32}$/;
+const CELL_LABEL_MAX = 64;
+// Una label che esce da questo nodo, o che arriva da un altro, e' testo
+// AUTO-DICHIARATO: la definizione locale e' gia' validata dal parser, ma il
+// payload che si espone e quello che si riceve vanno delimitati comunque.
+// Senza questo un peer puo' far attraversare la directory a una stringa lunga
+// e con a capo, che ogni consumatore poi renderizza.
+function safeCellLabel(value) {
+  if (typeof value !== 'string') return '';
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > CELL_LABEL_MAX) return '';
+  return /[\x00-\x1f\x7f]/.test(trimmed) ? '' : trimmed;
+}
 const NODE_ID_RE = /^[a-f0-9]{16,64}$/;
 const MESSAGE_ID_RE = /^[a-f0-9-]{16,64}$/;
@@ -24,6 +37,10 @@ function publicCells(status, instanceId, now = Date.now()) {
       id: `${instanceId}:${raw.cell}`,
       instanceId,
       cell: raw.cell,
+      // Il nome leggibile viaggia accanto all'id, mai al suo posto: chi riceve
+      // questa voce deve poter capire che ruolo occupa la cella senza dover
+      // interpretare un identificatore scelto da un altro nodo.
+      label: safeCellLabel(raw.label),
       tmuxSession: raw.tmuxSession,
       engine: typeof raw.engine === 'string' ? raw.engine : '',
       model: typeof raw.model === 'string' ? raw.model : '',
@@ -135,4 +152,4 @@ function cellsRoutes({ fleetP, instanceId, submit, readonly = () => false, now =
   return r;
 }
-module.exports = { cellsRoutes, publicCells, parseVisited, validIdentity };
+module.exports = { cellsRoutes, publicCells, parseVisited, validIdentity, safeCellLabel };

package/lib/fleet/builtin.js CHANGED Viewed

@@ -507,7 +507,10 @@ async function createBuiltinFleet(cfg = {}) {
     if (!Array.isArray(cells) || cells.length < 1 || cells.length > MAX_CELLS) {
       throw httpError(400, `cells deve contenere 1..${MAX_CELLS} definizioni`);
     }
-    const allowed = new Set(['id', 'cwd', 'cwdRel', 'engine', 'boot', 'model', 'models', 'permissionPolicies', 'commands', 'prompt']);
+    // `label` e' parte della definizione quanto `prompt`: senza di essa qui, un
+    // backup che la contiene verrebbe rifiutato in restore e il round-trip si
+    // spezzerebbe proprio sulle celle a cui e' stato dato un nome.
+    const allowed = new Set(['id', 'cwd', 'cwdRel', 'engine', 'boot', 'model', 'models', 'permissionPolicies', 'commands', 'prompt', 'label']);
     const seen = new Set();
     for (const cell of cells) {
       if (!cell || typeof cell !== 'object' || Array.isArray(cell)) throw httpError(400, 'definizione cell non valida');
@@ -864,6 +867,9 @@ async function createBuiltinFleet(cfg = {}) {
         permissionPolicies: { type: 'object', required: false, keyRef: 'engine.id', valueEnum: ['standard', 'unsafe'] },
         commands: { type: 'object', required: false, keyRef: 'engine.id', valueMax: CAPS.MAX_CELL_COMMAND_LEN, managedClient: 'shell' },
         prompt: { type: 'string', required: false, max: CAPS.MAX_PROMPT_LEN },
+        // Nome leggibile, distinto dall'id: quest'ultimo resta la chiave di
+        // indirizzamento e l'unica origine della sessione tmux.
+        label: { type: 'string', required: false, max: CAPS.MAX_LABEL_LEN },
       },
     };
   }

package/lib/fleet/cell-exec.js CHANGED Viewed

@@ -65,12 +65,14 @@ function promptCharsOk(prompt) {
 function validRestartPrompt(value) {
   if (value === undefined) return true;
   if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  if (Object.keys(value).some((key) => !['tmuxBin', 'tmuxSession', 'prompt', 'readyMs'].includes(key))) return false;
+  if (Object.keys(value).some((key) => !['tmuxBin', 'tmuxSession', 'prompt', 'readyMs', 'client', 'readyWaitMs'].includes(key))) return false;
   return typeof value.tmuxBin === 'string' && value.tmuxBin.length > 0 && value.tmuxBin.length <= 4096
     && !/[\0\r\n]/.test(value.tmuxBin)
     && typeof value.tmuxSession === 'string' && /^[\w.@%:+-]{1,128}$/.test(value.tmuxSession)
     && promptCharsOk(value.prompt)
-    && (value.readyMs === undefined || validInteger(value.readyMs, 0, 30000));
+    && (value.readyMs === undefined || validInteger(value.readyMs, 0, 30000))
+    && (value.client === undefined || value.client === '' || value.client === 'kimi' || value.client === 'claude')
+    && (value.readyWaitMs === undefined || validInteger(value.readyWaitMs, 0, 120000));
 }
 function validPayload(payload) {
@@ -138,24 +140,117 @@ function waitChild(child) {
   });
 }
-function scheduleRestartPrompt(config, childState, seams = {}) {
-  if (!config) return { cancel() {} };
-  let timer = null; let cancelled = false;
+// Delivery del bootstrap prompt per generazione (0.8.47, R2/R3).
+//
+// OWNER UNICO: per gli engine managed Kimi (client 'kimi'/'claude') il
+// supervisore consegna il prompt per TUTTE le generazioni, gen0 compresa —
+// il runtime non esegue MAI paste/Enter per questi engine (legge solo l'esito
+// bounded via opzione di pane @nc_delivery). Cosi' non esiste doppio writer
+// cross-generation: se gen0 muore durante l'attesa readiness, la sua delivery
+// viene cancellata e attesa PRIMA dello spawn di gen1, che ricevera' al
+// massimo una nuova consegna. Engine custom send-keys: contratto legacy
+// invariato (gen0 = runtime.injectPrompt; qui solo gen>0, paste senza Enter).
+//
+// CANCELLAZIONE (R3): cancel() ferma il timer E il polling in volo tramite
+// isCancelled valutato dentro deliverBootstrapPrompt (ogni poll, pre-paste,
+// pre-Enter); il chiamante fa cancel() + await settled prima dello spawn
+// della generazione successiva: zero paste/Enter da un task della generazione
+// precedente.
+//
+// REPORT: esito pubblicato con set-option -p @nc_delivery '<state>[:notReady]'
+// (solo enum chiusi; l'opzione muore col pane, nessuno state file). Best
+// effort: un set-option fallito lascia up() in report-timeout (onesto), la
+// consegna resta fatta.
+// CANCELLAZIONE (R3+R8): cancel() ferma il timer E il polling in volo tramite
+// isCancelled valutato dentro deliverBootstrapPrompt (ogni poll, pre-paste,
+// pre-Enter, post-Enter); il chiamante fa cancel() + await settled prima dello
+// spawn della generazione successiva. cancel() con timer ANCORA PENDENTE
+// (child uscito prima di readyMs, caso early-exit) risolve settled SUBITO:
+// mai deadlock (R8). settled risolve con l'esito della delivery: null se
+// nessun paste incerto, {state} se la generazione e' terminata con un
+// post-paste incerto (delivery-unknown / staged-not-submitted) — il main loop
+// NON auto-restarta in quel caso (R9: byte potenzialmente residui nel PTY del
+// pane riusato; fermo bounded + restart operatore).
+function startGenerationPrompt(config, generation, childState, seams = {}) {
+  if (!config) return null;
+  const classified = config.client === 'kimi' || config.client === 'claude';
+  if (!classified && generation === 0) return null;  // legacy: gen0 resta al runtime
   const setTimer = seams.setTimeout || setTimeout;
   const clearTimer = seams.clearTimeout || clearTimeout;
+  const runTmux = seams.tmuxExec || ((bin, args, opts = {}) => new Promise((resolve) => {
+    require('node:child_process').execFile(bin, args, { env: opts.env, timeout: opts.timeoutMs || 10000 },
+      (err, stdout, stderr) => resolve({ err, stdout: String(stdout || ''), stderr: String(stderr || ''), code: err ? (typeof err.code === 'number' ? err.code : 1) : 0 }));
+  }));
+  const paneTarget = process.env.TMUX_PANE || `=${config.tmuxSession}`;
+  const markDelivery = async (value) => {
+    if (!classified) return;
+    try { await runTmux(config.tmuxBin, ['set-option', '-p', '-t', paneTarget, '@nc_delivery', value], {}); }
+    catch (_) { /* best-effort: il report timeout di up() resta onesto */ }
+  };
+  let timer = null; let cancelled = false;
+  let settledDone = false; let settleResolve = null;
+  const settled = new Promise((resolve) => { settleResolve = resolve; });
+  const settle = (value) => {
+    if (settledDone) return;
+    settledDone = true;
+    settleResolve(value);
+  };
+  const isCancelled = () => cancelled || childState.exited === true;
   timer = setTimer(async () => {
     timer = null;
-    if (cancelled || childState.exited) return;
-    try {
-      const inject = seams.injectPrompt || require('./launch.js').injectPrompt;
-      await inject(config.tmuxBin, config.tmuxSession, config.prompt, {
-        target: process.env.TMUX_PANE || `=${config.tmuxSession}`,
-        readyMs: 0,
-      });
-    } catch (_) { /* keepalive must not die because prompt reinjection failed */ }
+    if (isCancelled()) { settle(null); return; }
+    const task = (async () => {
+      try {
+        if (classified) {
+          await markDelivery('');
+          const deliver = seams.deliverBootstrapPrompt
+            || require('./prompt-delivery.js').deliverBootstrapPrompt;
+          const result = await deliver({
+            tmuxBin: config.tmuxBin,
+            session: config.tmuxSession,
+            prompt: config.prompt,
+            client: config.client,
+            paneTarget: process.env.TMUX_PANE || undefined,
+            readyWaitMs: config.readyWaitMs,
+            isCancelled,
+          });
+          const state = result && typeof result.state === 'string' ? result.state : '';
+          const uncertain = state === 'delivery-unknown' || state === 'staged-not-submitted';
+          if (isCancelled()) {
+            // R9: la generazione e' finita. Propago SOLO gli esiti post-paste
+            // incerti (residuo PTY possibile); cancelled pre-paste e' pulito.
+            return uncertain ? { state } : null;
+          }
+          if (state) {
+            const kind = state === 'skipped-not-ready' && result.notReady ? `:${result.notReady}` : '';
+            await markDelivery(`${state}${kind}`);
+          }
+          // R12: l'esito post-paste incerto va conservato ANCHE se il child
+          // era vivo al ritorno di deliver: i byte possono restare nel PTY del
+          // pane e sommarsi al bootstrap della generazione successiva. Al
+          // prossimo child exit il main ferma il supervisor (no auto-restart).
+          return uncertain ? { state } : null;
+        }
+        const inject = seams.injectPrompt || require('./launch.js').injectPrompt;
+        await inject(config.tmuxBin, config.tmuxSession, config.prompt, {
+          target: paneTarget,
+          readyMs: 0,
+        });
+        return null;
+      } catch (_) { return null; /* keepalive must not die because prompt reinjection failed */ }
+    })();
+    settle(await task);
   }, config.readyMs ?? 400);
   timer.unref?.();
-  return { cancel() { cancelled = true; if (timer) clearTimer(timer); timer = null; } };
+  return {
+    settled,
+    // R8: timer ancora pendente -> settle IMMEDIATO (idempotente): il main
+    // loop non resta mai appeso su un child uscito prima di readyMs.
+    cancel() {
+      cancelled = true;
+      if (timer) { clearTimer(timer); timer = null; settle(null); }
+    },
+  };
 }
 async function main(argv = process.argv.slice(2), seams = {}) {
@@ -195,13 +290,26 @@ async function main(argv = process.argv.slice(2), seams = {}) {
     for (;;) {
       if (stopping) return 0;
       const startedAt = now();
-      current = spawnImpl(payload.command, payload.args, { env: childEnv, stdio: 'inherit' });
       const childState = { exited: false };
-      const prompt = generation > 0 ? scheduleRestartPrompt(payload.restartPrompt, childState, seams) : null;
+      const promptCtl = startGenerationPrompt(payload.restartPrompt, generation, childState, seams);
+      current = spawnImpl(payload.command, payload.args, { env: childEnv, stdio: 'inherit' });
       const result = await waitChild(current);
       childState.exited = true;
-      prompt?.cancel();
       current = null;
+      // R2/R3: la generazione e' finita. Cancella la delivery in volo e ATTESA
+      // del suo termine PRIMA di qualunque nuovo spawn. R9: se l'esito e' un
+      // post-paste incerto (delivery-unknown / staged-not-submitted) i byte del
+      // prompt possono essere residui nel PTY del pane riusato: NIENTE auto-
+      // restart — fermo bounded del supervisor, restart esplicito operatore.
+      if (promptCtl) {
+        promptCtl.cancel();
+        const promptOutcome = await promptCtl.settled;
+        if (promptOutcome && (promptOutcome.state === 'delivery-unknown'
+          || promptOutcome.state === 'staged-not-submitted')) {
+          writeError('nexuscrew cell supervisor stopped: uncertain prompt delivery (operator restart required)\n');
+          return result.signal ? 128 : (result.code || 1);
+        }
+      }
       if (result.error) {
         writeError(`${sanitizeSpawnError(result.error, payload.command)}\n`);
         return 1;
@@ -246,5 +354,5 @@ if (require.main === module) {
 module.exports = {
   DEFAULT_SUPERVISE, parseArgs, validSupervise, validRestartPrompt, validPayload,
-  receivePayload, sanitizeSpawnError, normalizeSupervise, waitChild, scheduleRestartPrompt, main,
+  receivePayload, sanitizeSpawnError, normalizeSupervise, waitChild, startGenerationPrompt, main,
 };

package/lib/fleet/definitions.js CHANGED Viewed

@@ -378,6 +378,21 @@ function parseCell(c, engineIds, engineMap = new Map(), { allowLegacyTmuxNames =
     prompt = c.prompt;
   }
+  // label (opzionale): nome LEGGIBILE della cella, distinto dall'id.
+  // L'id resta la chiave stabile con cui si indirizza una cella e con cui si
+  // deriva la sessione tmux; la label e' solo cio' che un umano legge. Senza
+  // questa distinzione l'id fa anche da nome, e un nodo che battezza la propria
+  // cella come il motore la espone cosi' a tutta la rete: chi la riceve non ha
+  // modo di sapere che ruolo occupa. Stessa regola gia' usata per la label
+  // degli engine e per quella dei nodi: stampabile, non vuota, max 64.
+  let label;
+  if (c.label !== undefined) {
+    if (typeof c.label !== 'string') return null;
+    const trimmed = c.label.trim();
+    if (!trimmed || trimmed.length > MAX_LABEL_LEN || !isPrintable(trimmed)) return null;
+    label = trimmed;
+  }
   // tmuxSession: campo esplicito o derivato da id. UNIVOCO (check in caller).
   // Il nome CANONICO e' tmux-safe (v2 per id puntati): tmux normalizza '.' in
   // '_' nei nomi sessione, per cui `cloud-agy.native` diverrebbe `cloud-agy_native`
@@ -422,6 +437,7 @@ function parseCell(c, engineIds, engineMap = new Map(), { allowLegacyTmuxNames =
   if (permissionPolicies) out.permissionPolicies = permissionPolicies;
   if (commands && Object.keys(commands).length) out.commands = commands;
   if (prompt !== undefined) out.prompt = prompt;
+  if (label !== undefined) out.label = label;
   if (legacyTmuxSession) {
     Object.defineProperty(out, 'legacyTmuxSession', {
       value: legacyTmuxSession, enumerable: false, configurable: false,

package/lib/fleet/launch.js CHANGED Viewed

@@ -20,6 +20,7 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const crypto = require('node:crypto');
 const { execFile } = require('node:child_process');
 const { minimalRuntimeEnv } = require('../runtime/env.js');
 const { codeOf, phaseOf } = require('./causes.js');
@@ -355,34 +356,88 @@ async function waitStablePane(tmuxBin, target, { env, readyMs }) {
   }
 }
-// Iniezione prompt send-keys via bracketed paste (come skills/.../nc-send):
-// load-buffer del prompt in un buffer nominato + paste-buffer -p (bracketed),
-// poi cleanup. Readiness best-effort: se la sessione non e' viva quando paste-iamo
-// (command gia' uscito) NON digita (design §9e). Ritorna {injected, reason}.
+// Risolve il pane id (%N) esatto della sessione, o verifica un %N gia' noto.
+// Contratto submitToSession (R5): output session_name + pane_dead + pane_id,
+// parsing ESATTO per campi (mai regex %N libera), session verificata uguale
+// a quella attesa prima di qualunque paste/Enter. Ritorna null se il pane non
+// e' risolvibile, morto, di un'altra sessione o diverso dal %N atteso.
+async function resolveSessionPane(tmuxBin, session, { env, exec, target } = {}) {
+  const run = exec || tmuxExec;
+  const to = target || `=${session}`;
+  const r = await run(tmuxBin,
+    ['display-message', '-p', '-t', to, '#{session_name}\t#{pane_dead}\t#{pane_id}'],
+    { env, timeoutMs: 2000 });
+  if (r.err) return null;
+  const fields = r.stdout.trim().split('\t');
+  if (fields.length !== 3) return null;
+  const [sess, dead, pane] = fields;
+  if (dead !== '0') return null;                     // morto o non bounded
+  if (!/^%[0-9]+$/.test(pane)) return null;
+  if (typeof session === 'string' && session && sess !== session) return null;
+  if (target && target.startsWith('%') && pane !== target) return null;
+  return pane;
+}
+// Stadio sicuro del testo nel composer del TUI (0.8.47): temp file wx/0600 con
+// nome random + buffer tmux random per invio + bracketed paste sul %N esatto
+// risolto subito prima. NESSUN Enter: la sottomissione e' una decisione
+// separata del chiamante (solo deliverBootstrapPrompt, per kimi.native e
+// claude.kimi-code). Niente buffer condiviso 'ncsend': due celle concorrenti
+// non possono piu' sovrascriversi il buffer a vicenda.
+// Ritorna { ok, stage, paneId?, reason } con reason costante (mai stderr/pane).
+async function securePaste(tmuxBin, session, text, { env, exec, tmpdir, target, fsImpl } = {}) {
+  const run = exec || tmuxExec;
+  const fsx = fsImpl || fs;
+  if (!promptCharsOk(text)) {
+    return { ok: false, stage: 'validate', reason: 'prompt contiene byte di controllo (rifiutato)' };
+  }
+  const paneId = await resolveSessionPane(tmuxBin, session, { env, exec: run, target });
+  if (!paneId) return { ok: false, stage: 'resolve', reason: 'pane non risolvibile' };
+  const nonce = crypto.randomBytes(8).toString('hex');
+  const buffer = `ncstage-${nonce}`;
+  const tmp = path.join(tmpdir || os.tmpdir(), `.ncstage-${process.pid}-${nonce}.txt`);
+  let loaded = false;
+  try {
+    fsx.writeFileSync(tmp, text, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    try { fsx.chmodSync(tmp, 0o600); } catch (_) { /* best-effort */ }
+    const load = await run(tmuxBin, ['load-buffer', '-b', buffer, tmp], { env });
+    if (load.err) return { ok: false, stage: 'load', reason: 'buffer non disponibile' };
+    loaded = true;
+    // R4: da qui in poi il paste e' stato TENTATO: qualunque throw/rejection
+    // dell'executor e' post-paste (stage 'paste'), mai classificato come
+    // pre-paste 'load' — il composer potrebbe contenere testo parziale o
+    // completo e un retry duplicherebbe il prompt (G1).
+    try {
+      const paste = await run(tmuxBin, ['paste-buffer', '-p', '-t', paneId, '-b', buffer], { env });
+      if (paste.err) return { ok: false, stage: 'paste', reason: 'paste-buffer failed' };
+      return { ok: true, stage: 'pasted', paneId };
+    } catch (_) {
+      return { ok: false, stage: 'paste', reason: 'paste-buffer failed' };
+    }
+  } catch (_) {
+    return { ok: false, stage: 'load', reason: 'buffer non disponibile' };
+  } finally {
+    try { fsx.unlinkSync(tmp); } catch (_) { /* best-effort */ }
+    if (loaded) { try { await run(tmuxBin, ['delete-buffer', '-b', buffer], { env }); } catch (_) { /* best-effort */ } }
+  }
+}
+// Iniezione prompt send-keys via bracketed paste (contratto legacy per engine
+// custom promptMode 'send-keys': paste SENZA Enter, invariato — 0.8.47 G4).
+// Readiness best-effort: se la sessione non e' viva quando paste-iamo (command
+// gia' uscito) NON digita (design §9e). Ritorna {injected, reason}.
+// Trasporto backportato su securePaste: buffer random, temp wx/0600, pane %N.
 async function injectPrompt(tmuxBin, session, prompt, { env, readyMs = 400, target, engine, cell } = {}) {
   if (!promptCharsOk(prompt)) {
     return { injected: false, reason: 'prompt contiene byte di controllo (rifiutato)' };
   }
-  let tmp = null;
-  try {
-    tmp = path.join(os.tmpdir(), `.ncsend.${session}.${process.pid}.txt`);
-    fs.writeFileSync(tmp, prompt, { mode: 0o600 });
-    fs.chmodSync(tmp, 0o600);
-    const alive = await waitAlive(tmuxBin, session, { env, readyMs });
-    if (!alive) return { injected: false, reason: 'sessione non viva (command uscito?): nessuna digitazione' };
-    // Target esatto: pane id (%N) se disponibile, altrimenti '=sessione' (match
-    // esatto, mai prefix-match) — audit impl #5.
-    const to = target || `=${session}`;
-    await tmuxExec(tmuxBin, ['load-buffer', '-b', 'ncsend', tmp], { env });
-    const paste = await tmuxExec(tmuxBin, ['paste-buffer', '-p', '-t', to, '-b', 'ncsend'], { env });
-    if (paste.err) return { injected: false, reason: redactSecrets(`paste-buffer failed: ${paste.stderr.trim()}`, engine, cell) };
-    return { injected: true, reason: 'bracketed paste (load-buffer + paste-buffer -p)' };
-  } finally {
-    try { if (tmp) fs.unlinkSync(tmp); } catch (_) { /* best-effort */ }
-    try { await tmuxExec(tmuxBin, ['delete-buffer', '-b', 'ncsend'], { env }); } catch (_) { /* best-effort */ }
+  const alive = await waitAlive(tmuxBin, session, { env, readyMs });
+  if (!alive) return { injected: false, reason: 'sessione non viva (command uscito?): nessuna digitazione' };
+  const stage = await securePaste(tmuxBin, session, prompt, { env, target });
+  if (!stage.ok) {
+    return { injected: false, reason: redactSecrets(stage.reason, engine, cell) };
   }
+  return { injected: true, reason: 'bracketed paste (load-buffer + paste-buffer -p)' };
 }
 module.exports = {
@@ -400,6 +455,8 @@ module.exports = {
   waitAlive,
   waitStablePane,
   injectPrompt,
+  resolveSessionPane,
+  securePaste,
   redactSecrets,
   sanitizeEarlyDiagnostic,
 };

package/lib/fleet/managed.js CHANGED Viewed

@@ -921,7 +921,15 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
     // TUI interattivo nella cwd della cella.
     if (model) args.push('--model', model);
   }
-  if (spec.client !== 'shell' && spec.client !== 'kimi' && cell?.prompt) args.push(cell.prompt);
+  // Prompt su argv (0.8.47): SOLO i client che non hanno un percorso classified
+  // delivery. kimi.native e claude.kimi-code usano promptMode 'send-keys' con
+  // deliverBootstrapPrompt (readiness classificata + at-most-once): il prompt
+  // NON deve mai comparire nel loro argv (visibile in ps / perso dietro
+  // consenso/onboarding). Gli altri managed conservano il contratto argv
+  // (finding separato, fuori da questa patch).
+  const promptViaDelivery = spec.client === 'kimi'
+    || (spec.client === 'claude' && spec.provider === 'kimi-code');
+  if (spec.client !== 'shell' && !promptViaDelivery && cell?.prompt) args.push(cell.prompt);
   // nexuscrew-store source: neutralize the profile's env set in the composed
   // child env (unset, never empty), so the runtime cannot leak credentials that
   // the local store is meant to own.
@@ -933,7 +941,7 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
   }
   return { ok: true, info, engine: {
     ...engine, command, args, env,
-    promptMode: spec.client === 'kimi' ? 'send-keys' : 'managed-argv', clientBinary: info.binary,
+    promptMode: promptViaDelivery ? 'send-keys' : 'managed-argv', clientBinary: info.binary,
     ...(spec.client === 'shell' ? { shellOneShot } : {}),
   } };
 }