npm - @mmmbuto/nexuscrew - Versions diffs - 0.8.45 → 0.8.47 - Mend

@mmmbuto/nexuscrew 0.8.45 → 0.8.47

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 (12) hide show

package/CHANGELOG.md +46 -0
package/README.md +1 -1
package/frontend/dist/assets/{index-DNFEGdog.js → index-Db2ivuxA.js} +28 -28
package/frontend/dist/index.html +1 -1
package/frontend/dist/version.json +1 -1
package/lib/fleet/builtin.js +19 -2
package/lib/fleet/cell-exec.js +126 -18
package/lib/fleet/launch.js +80 -23
package/lib/fleet/managed.js +53 -5
package/lib/fleet/prompt-delivery.js +275 -0
package/lib/fleet/runtime.js +49 -10
package/package.json +1 -1

package/frontend/dist/index.html CHANGED Viewed

@@ -11,7 +11,7 @@
   <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-DNFEGdog.js"></script>
+  <script type="module" crossorigin src="/assets/index-Db2ivuxA.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-BAq6N1Md.css">
 </head>
 <body>

package/frontend/dist/version.json CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":"0.8.45"}
1	+ {"version":"0.8.47"}

package/lib/fleet/builtin.js CHANGED Viewed

@@ -34,7 +34,7 @@ const {
   resolveCwd, normalizeCwdRel, deriveCwdRel,
 } = require('./definitions.js');
 const {
-  publicCatalog, describeManaged, describeCatalogCredential, defaultShellEngine, defaultAgyEngine,
+  publicCatalog, describeManaged, describeCatalogCredential, defaultShellEngine, defaultAgyEngine, defaultKimiEngine,
 } = require('./managed.js');
 const { validEnvKey } = require('./env-key.js');
 const { setCredential, removeCredential } = require('./credentials.js');
@@ -107,6 +107,21 @@ function backfillAgyEngine(defsPath, defs, cfg = {}) {
   try { return atomicWrite(defsPath, draft); } catch (_) { return defs; }
 }
+// Backfill dell'engine Kimi Code CLI nativo: installazioni esistenti ricevono
+// kimi.native in modo idempotente e non distruttivo. Nessun platform gate: il
+// CLI gira ovunque giri Node e su Termux il resolver applica gia' il workaround
+// shebang. Idempotente (gia' presente -> skip), NON sovrascrive un id
+// 'kimi.native' gia' scelto dall'utente per altro (collisione -> skip, store
+// invariato), rispetta il cap MAX_ENGINES. Non tocca CELLE.
+function backfillKimiEngine(defsPath, defs) {
+  if (!defs || defs.engines.some((engine) => engine.managed?.client === 'kimi')) return defs;
+  if (defs.engines.some((engine) => engine.id === 'kimi.native')) return defs;
+  if (defs.engines.length >= CAPS.MAX_ENGINES) return defs;
+  const draft = draftFrom(defs);
+  draft.engines.push(defaultKimiEngine());
+  try { return atomicWrite(defsPath, draft); } catch (_) { return defs; }
+}
 // Applica engine + modello + policy come un'unica transizione. Ogni engine ricorda
 // il proprio ultimo modello E l'ultima policy; passando a un altro engine né
 // l'uno né l'altra attraversano il confine. La policy e' PER-CELL PER-ENGINE:
@@ -275,6 +290,7 @@ async function createBuiltinFleet(cfg = {}) {
     }
     boot = backfillShellEngine(defsPath, boot);
     boot = backfillAgyEngine(defsPath, boot, cfg);
+    boot = backfillKimiEngine(defsPath, boot);
   }
   // Adopt or create the shared server before exposing a mutable Fleet. Reapply
@@ -808,7 +824,7 @@ async function createBuiltinFleet(cfg = {}) {
         rc: { type: 'boolean', required: false, default: false },
         managed: {
           type: 'object', requiredFor: 'managed',
-          client: { type: 'enum', values: ['claude', 'codex', 'codex-vl', 'pi', 'agy', 'shell'] },
+          client: { type: 'enum', values: ['claude', 'codex', 'codex-vl', 'pi', 'agy', 'kimi', 'shell'] },
           provider: { type: 'catalog', source: 'managedCatalog' },
           credentialProfile: { type: 'string', required: false, max: 32 },
           model: { type: 'string', required: false, max: CAPS.MAX_MODEL_VAL_LEN },
@@ -873,6 +889,7 @@ module.exports = {
   createBuiltinFleet,
   backfillShellEngine,
   backfillAgyEngine,
+  backfillKimiEngine,
   resolveCellCwd,
   composeLaunchArgv,
   composeClientInvocation,

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/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

@@ -65,7 +65,7 @@ const MANAGED_KEYS = new Set(['client', 'provider', 'credentialProfile', 'model'
 // resolution order (runtime -> store -> shell -> key files -> legacy) so a
 // pre-WP1 fleet.json migrates no-op: no existing cell changes resolution.
 const CREDENTIAL_SOURCES = Object.freeze(['environment', 'nexuscrew-store', 'auto']);
-const CLIENT_LABELS = Object.freeze({ claude: 'Claude Code', codex: 'Codex', 'codex-vl': 'Codex-VL', pi: 'Pi', agy: 'Agy', shell: 'Shell' });
+const CLIENT_LABELS = Object.freeze({ claude: 'Claude Code', codex: 'Codex', 'codex-vl': 'Codex-VL', pi: 'Pi', agy: 'Agy', kimi: 'Kimi Code CLI', shell: 'Shell' });
 const PROVIDER_ID_RE = /^[a-z][a-z0-9_-]{0,31}$/;
 function validBaseUrl(value) {
@@ -142,6 +142,16 @@ const CATALOG = Object.freeze([
   // (core) per la UI; describeManaged lo dichiara non configurato altrove.
   // Termux/Windows restano fuori dal primary: l'utente usa agy via shell.local.
   { id: 'agy.native', client: 'agy', provider: 'native', label: 'Agy', auth: 'login', protocol: 'agy_native', core: true },
+  // Kimi Code CLI nativo (@moonshot-ai/kimi-code): client gestito con auth
+  // delegata al login del CLI (device-code flow, provider in config.toml).
+  // NexusCrew non legge ne' copia credenziali: nessun env provider, nessun
+  // token su argv. Distinto dal provider claude.kimi-code (adattatore Claude
+  // Code sull'endpoint Kimi), che resta il percorso K3 gestito via ANTHROPIC_*.
+  // Non e' un default seed: backfill idempotente in builtin.js, come Agy ma
+  // senza platform gate (il CLI gira ovunque giri Node; su Termux il resolver
+  // applica gia' il workaround shebang needsExplicitNode).
+  { id: 'kimi.native', client: 'kimi', provider: 'native', label: 'Kimi account (CLI login)', auth: 'login', protocol: 'kimi_native', core: true, notice: 'kimi-native' },
 ]);
 function profileFor(client, provider, credentialProfile) {
@@ -234,6 +244,18 @@ function defaultAgyEngine() {
   };
 }
+// Engine Kimi Code CLI per il backfill (builtin.js): standard di default, auth
+// delegata al login nativo del CLI, niente remote-control. Non e' un default seed.
+function defaultKimiEngine() {
+  const profile = CATALOG.find((entry) => entry.id === 'kimi.native');
+  return {
+    id: profile.id,
+    label: CLIENT_LABELS.kimi,
+    rc: false,
+    managed: { client: 'kimi', provider: 'native', model: '', permissionPolicy: 'standard' },
+  };
+}
 function parseAssignments(raw) {
   const out = {};
   for (const line of raw.split(/\r?\n/)) {
@@ -753,6 +775,11 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
   if (effectivePolicy === 'unsafe') {
     if (spec.client === 'claude' || spec.client === 'agy') args.push('--dangerously-skip-permissions');
     if (spec.client === 'codex' || spec.client === 'codex-vl') args.push('--dangerously-bypass-approvals-and-sandbox');
+    // Kimi Code CLI: unsafe mappa su --yolo (auto-approva le chiamate tool
+    // ordinarie ma l'agente puo' ancora fare domande). --auto (fully
+    // autonomous, nessuna domanda) NON e' mappato: il contratto NexusCrew
+    // distingue solo standard/unsafe e il default resta interattivo.
+    if (spec.client === 'kimi') args.push('--yolo');
   }
   let shellOneShot = false;
   if (spec.client === 'shell') {
@@ -884,8 +911,25 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
     // dal push generico qui sotto). Senza prompt parte il TUI interattivo `agy`.
     if (model) args.push('--model', model);
     if (cell?.prompt) args.push('--prompt-interactive');
+  } else if (spec.client === 'kimi') {
+    // Kimi Code CLI nativo: auth e provider gestiti dal CLI (login device-code,
+    // config.toml): niente env provider, niente credenziali su argv. Il CLI non
+    // documenta un flag prompt interattivo (`kimi -p` e' non-interattivo, senza
+    // TUI): il prompt della cella NON va su argv ma viene iniettato via
+    // bracketed paste dopo la readiness (promptMode 'send-keys' qui sotto,
+    // reiniettato anche ai restart supervisionati). Senza argomenti parte il
+    // TUI interattivo nella cwd della cella.
+    if (model) args.push('--model', model);
   }
-  if (spec.client !== 'shell' && 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.
@@ -896,7 +940,8 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
     args.unshift(info.binary);
   }
   return { ok: true, info, engine: {
-    ...engine, command, args, env, promptMode: 'managed-argv', clientBinary: info.binary,
+    ...engine, command, args, env,
+    promptMode: promptViaDelivery ? 'send-keys' : 'managed-argv', clientBinary: info.binary,
     ...(spec.client === 'shell' ? { shellOneShot } : {}),
   } };
 }
@@ -909,7 +954,10 @@ function publicCatalog() {
     protocols: [...(p.protocols || [p.protocol])], supportsUnsafe: !['pi', 'shell'].includes(p.client), requiresModel: !!p.requiresModel || !!p.custom,
     permissionPolicyDefault: p.client === 'claude' ? 'unsafe' : 'standard',
     rc: !!p.rc, custom: !!p.custom, default: !!p.default, notice: p.notice || '',
-    credentialEnv: p.auth === 'dynamic' ? !!p.credentialEnv : (ENV_KEY_RE.test(p.auth || '') ? p.auth : false),
+    // 'login'/'none' non sono variabili d'ambiente: nessuna KEY section per gli
+    // engine che delegano l'auth al login del CLI (rappresentazione onesta).
+    credentialEnv: p.auth === 'dynamic' ? !!p.credentialEnv
+      : (p.auth !== 'login' && p.auth !== 'none' && ENV_KEY_RE.test(p.auth || '') ? p.auth : false),
     defaultEnvKey: p.defaultEnvKey || '',
   }));
 }
@@ -918,7 +966,7 @@ module.exports = {
   CATALOG, OLLAMA_CLOUD_MODELS, OLLAMA_CONTEXT, ALIBABA_TOKEN_PLAN_MODELS,
   ALIBABA_CODEX_MODELS, ALIBABA_TOKEN_PLAN_CONTEXT, ALIBABA_PI_MODELS,
   CLIENT_LABELS, normalizeManagedSpec, profileFor,
-  defaultDefinitions, defaultShellEngine, defaultAgyEngine, describeManaged, describeCatalogCredential, discoverOllamaModels, resolveManagedEngine, needsExplicitNode,
+  defaultDefinitions, defaultShellEngine, defaultAgyEngine, defaultKimiEngine, describeManaged, describeCatalogCredential, discoverOllamaModels, resolveManagedEngine, needsExplicitNode,
   discoverPiModels, EXTERNAL_DISCOVERY_TIMEOUT_MS, parseEnvFile, parseProviderShellFile, findBinary, publicCatalog, writePiProviderExtension,
   providerKeyPaths, parseProviderKeyFiles, credentialSources, credential,
   credentialEnvNeutralizeSet, applyStoreNeutralization,