@arka-labs/nemesis 1.2.0

package/src/commands/services.js

@@ -0,0 +1,705 @@
+import { interactiveMenu } from '../../lib/ui/menu.js';
+import { askText, askConfirm } from '../../lib/ui/prompt.js';
+import { createSpinner } from '../../lib/ui/spinner.js';
+import { renderTable } from '../../lib/ui/table.js';
+import { titledBox } from '../../lib/ui/box.js';
+import { style } from '../../lib/ui/colors.js';
+import { writeFileSync, readFileSync, unlinkSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { BACK_ITEM, HOME_ITEM, pickFromList, ensureProject } from './_helpers.js';
+import {
+  PROVIDERS, addConnexion, listConnexions,
+  removeConnexion, updateConnexionStatus,
+} from '../../lib/core/connexions.js';
+import { testConnection, liveTestConnection } from '../../lib/sync/llm-client.js';
+import { resolveNotesDir, resolveCrDir, ensureDir } from '../../lib/core/notewriter/paths.js';
+import {
+  SERVICE_IDS, SERVICE_LABELS, SERVICE_DEFAULTS,
+  readServices, writeServices, assignService,
+} from '../../lib/core/services.js';
+import {
+  ALL_HOOKS, getHookStatus, installHooks, removeHooks,
+  activateSingleHook, deactivateSingleHook,
+} from '../../lib/kairos/hook-installer.js';
+
+const HELP = `
+nemesis services — Gestion des connexions LLM et services
+
+Usage: nemesis services [subcommand]
+
+Subcommands:
+  connexions         Gerer les connexions LLM
+  connexions add     Ajouter une connexion
+  connexions list    Lister les connexions
+  connexions test    Tester une connexion (health check)
+  connexions live    Tester en simulation reelle (appel LLM)
+  connexions remove  Supprimer une connexion
+  hooks              Gerer les hooks Claude Code (menu interactif)
+  hooks status       Etat des hooks
+  hooks setup        Activer tous les hooks
+  hooks reset        Desactiver tous les hooks
+  config             Affecter connexions aux services (ODM-CLI-012)
+  status             Vue d'ensemble des services (ODM-CLI-012)
+  -h, --help         Aide
+`;
+
+export async function handler({ args, flags, config }) {
+  if (flags.help || args.includes('--help') || args.includes('-h')) {
+    console.log(HELP);
+    return;
+  }
+
+  let sub = args[0];
+  let subArgs = args.slice(1);
+
+  if (!sub) {
+    sub = await interactiveMenu([
+      { label: 'connexions', value: 'connexions', description: 'Gerer les connexions LLM' },
+      { label: 'hooks',      value: 'hooks',      description: 'Gerer les hooks Claude Code' },
+      { label: 'config',     value: 'config',     description: 'Affecter aux services' },
+      { label: 'status',     value: 'status',     description: 'Etat des services' },
+      BACK_ITEM,
+      HOME_ITEM,
+    ], { title: 'nemesis services' });
+    if (!sub || sub === '__back__') return '__back__';
+    if (sub === '__home__') return '__home__';
+    subArgs = [];
+  }
+
+  switch (sub) {
+    case 'connexions': return handleConnexions(subArgs, flags, config);
+    case 'hooks': return handleHooks(subArgs, flags, config);
+    case 'config': return handleConfig(subArgs, flags, config);
+    case 'status': return handleStatus(subArgs, flags, config);
+    default:
+      console.log(`  Sous-commande inconnue : ${sub}`);
+      console.log(HELP);
+  }
+}
+
+async function handleConnexions(args, flags, config) {
+  let sub = args[0];
+  let subArgs = args.slice(1);
+
+  if (!sub) {
+    sub = await interactiveMenu([
+      { label: 'add',    value: 'add',    description: 'Ajouter une connexion' },
+      { label: 'list',   value: 'list',   description: 'Lister les connexions' },
+      { label: 'test',   value: 'test',   description: 'Tester une connexion (health check)' },
+      { label: 'live',   value: 'live',   description: 'Test reel — appel LLM' },
+      { label: 'remove', value: 'remove', description: 'Supprimer une connexion' },
+      BACK_ITEM,
+      HOME_ITEM,
+    ], { title: 'Connexions LLM' });
+    if (!sub || sub === '__back__') return '__back__';
+    if (sub === '__home__') return '__home__';
+    subArgs = [];
+  }
+
+  switch (sub) {
+    case 'add':    return handleConnexionsAdd(subArgs, flags, config);
+    case 'list':   return handleConnexionsList(flags, config);
+    case 'test':   return handleConnexionsTest(subArgs, flags, config);
+    case 'live':   return handleConnexionsLive(subArgs, flags, config);
+    case 'remove': return handleConnexionsRemove(subArgs, flags, config);
+  }
+}
+
+// ── connexions add ──────────────────────────────────────────────────
+
+async function handleConnexionsAdd(_args, _flags, _config) {
+  console.log('');
+
+  // 1. Nom
+  const name = await askText('Nom de la connexion');
+  if (!name) return;
+
+  // 2. Provider
+  const providerItems = PROVIDERS.map(p => ({
+    label: p.label, value: p.id, description: '',
+  }));
+  const provider = await interactiveMenu(providerItems, { title: 'Provider' });
+  if (!provider) return;
+  const providerDef = PROVIDERS.find(p => p.id === provider);
+
+  // 3. Type d'authentification
+  let authType;
+  if (providerDef.authTypes.length > 1) {
+    const authItems = providerDef.authTypes.map(t => ({
+      label: t === 'api_key' ? 'API Key' : t === 'token' ? 'Token' : 'Aucune',
+      value: t, description: '',
+    }));
+    authType = await interactiveMenu(authItems, { title: 'Type d\'authentification' });
+    if (!authType) return;
+  } else {
+    authType = providerDef.authTypes[0];
+  }
+
+  // 4. Modele
+  const model = await askText('Modele (laisser vide pour defaut)', '');
+
+  // 5. Credential
+  let credential = null;
+  if (authType !== 'none') {
+    credential = await askText(authType === 'api_key' ? 'Cle API' : 'Token');
+    if (!credential) return;
+  }
+
+  // 6. Endpoint
+  let endpoint = null;
+  if (provider === 'custom') {
+    endpoint = await askText('Endpoint URL');
+    if (!endpoint) return;
+  } else if (provider === 'ollama') {
+    endpoint = await askText('URL Ollama', 'http://localhost:11434');
+  }
+
+  // 7. CLI args
+  let cliArgs = null;
+  if (provider === 'cli_tools') {
+    cliArgs = await askText('Arguments CLI (optionnel)', '');
+  }
+
+  // 8. Creer + test auto
+  const spinner = createSpinner('Test de connexion...');
+  spinner.start();
+  const connexion = addConnexion({
+    name, provider, authType, model: model || null,
+    credential, endpoint, cliArgs: cliArgs || null,
+  });
+  const testResult = await testConnection(connexion);
+  updateConnexionStatus(connexion.id, testResult.ok ? 'connected' : 'error', testResult.latency);
+  if (testResult.ok) {
+    spinner.stop(`Connexion etablie \u2014 latence ${testResult.latency}ms`);
+  } else {
+    spinner.fail(`Echec connexion : ${testResult.error}`);
+  }
+
+  // 9. Confirmation
+  console.log(`  ${style.green('\u2713')} Connexion "${name}" creee`);
+  console.log(`     ID : ${style.dim(connexion.id)}`);
+  console.log('');
+}
+
+// ── connexions list ─────────────────────────────────────────────────
+
+async function handleConnexionsList(_flags, _config) {
+  const connexions = listConnexions();
+  if (connexions.length === 0) {
+    console.log(`\n  ${style.dim('Aucune connexion configuree.')}`);
+    console.log(`  ${style.dim('Utilisez')} nemesis services connexions add\n`);
+    return;
+  }
+  const rows = connexions.map(c => ({
+    nom: c.name,
+    provider: c.provider,
+    statut: c.status === 'connected'
+      ? `${style.green('\u25CF')} actif`
+      : c.status === 'error'
+        ? `${style.red('\u25CF')} erreur`
+        : `${style.dim('\u25CB')} non teste`,
+    latence: c.latency ? `${c.latency}ms` : '\u2014',
+  }));
+  console.log('');
+  console.log(titledBox('Connexions LLM', [
+    renderTable(
+      [{ key: 'nom', label: 'Nom' }, { key: 'provider', label: 'Provider' },
+       { key: 'statut', label: 'Statut' }, { key: 'latence', label: 'Latence' }],
+      rows,
+    ),
+  ], { border: style.nemesisAccent }));
+  console.log('');
+}
+
+// ── connexions test ─────────────────────────────────────────────────
+
+async function handleConnexionsTest(args, _flags, _config) {
+  const connexions = listConnexions();
+  if (connexions.length === 0) {
+    console.log(`\n  ${style.dim('Aucune connexion configuree.')}\n`);
+    return;
+  }
+
+  let cx = args[0] ? connexions.find(c => c.id === args[0] || c.name === args[0]) : null;
+  if (!cx) {
+    const selected = await pickFromList(
+      connexions.map(c => ({ id: c.id, title: c.provider, ...c })),
+      {
+        title: 'Tester quelle connexion ?',
+        labelFn: (c) => `${c.name} (${c.provider})`,
+      },
+    );
+    if (!selected) return;
+    cx = connexions.find(c => c.id === selected);
+  }
+  if (!cx) return;
+
+  const spinner = createSpinner(`Test de connexion "${cx.name}"...`);
+  spinner.start();
+  const result = await testConnection(cx);
+  updateConnexionStatus(cx.id, result.ok ? 'connected' : 'error', result.latency);
+  if (result.ok) {
+    spinner.stop('Test reussi');
+    console.log(`  ${style.green('\u2713')} Auth valide`);
+    if (cx.model) console.log(`  ${style.green('\u2713')} Modele ${cx.model} accessible`);
+    console.log(`  ${style.green('\u2713')} Latence : ${result.latency}ms`);
+  } else {
+    spinner.fail('Test echoue');
+    console.log(`  ${style.red('\u2717')} ${result.error}`);
+  }
+  console.log('');
+}
+
+// ── connexions live (test reel LLM) ─────────────────────────────────
+
+async function handleConnexionsLive(args, flags, config) {
+  const connexions = listConnexions();
+  if (connexions.length === 0) {
+    console.log(`\n  ${style.dim('Aucune connexion configuree.')}\n`);
+    return;
+  }
+
+  let cx = args[0] ? connexions.find(c => c.id === args[0] || c.name === args[0]) : null;
+  if (!cx) {
+    const selected = await pickFromList(
+      connexions.map(c => ({ id: c.id, title: c.provider, ...c })),
+      {
+        title: 'Test reel — quelle connexion ?',
+        labelFn: (c) => `${c.name} (${c.provider}${c.model ? ' \u2014 ' + c.model : ''})`,
+      },
+    );
+    if (!selected) return;
+    cx = connexions.find(c => c.id === selected);
+  }
+  if (!cx) return;
+
+  // --- Step 1: Appel LLM reel ---
+  const spinner = createSpinner(`Appel LLM reel vers "${cx.name}" (${cx.provider})...`);
+  spinner.start();
+  const result = await liveTestConnection(cx);
+  updateConnexionStatus(cx.id, result.ok ? 'connected' : 'error', result.latency);
+
+  if (!result.ok) {
+    spinner.fail('Echec appel LLM');
+    console.log('');
+    console.log(titledBox('Test reel — Echec', [
+      `Connexion : ${cx.name}`,
+      `Provider  : ${cx.provider}`,
+      `Modele    : ${cx.model || '(defaut)'}`,
+      `Latence   : ${result.latency}ms`,
+      '',
+      `${style.red('\u2717')} ${result.error}`,
+    ], { border: style.red }));
+    console.log('');
+    return;
+  }
+  spinner.stop('Appel LLM reussi');
+
+  // --- Step 2: Validation ecriture notes/cr ---
+  const project = await ensureProject(config, flags).catch(() => null);
+  const testAgent = '_live-test_';
+  let writeOk = false;
+  let noteWriteOk = false;
+  let crWriteOk = false;
+  let cleanupOk = false;
+
+  if (project) {
+    const root = project.root || config.cwd;
+    const notesDir = resolveNotesDir(root, testAgent);
+    const crDir = resolveCrDir(root, testAgent);
+    const testNoteFile = join(notesDir, '_live-test-note.json');
+    const testCrFile = join(crDir, '_live-test-cr.json');
+    const testPayload = JSON.stringify({ _test: true, ts: new Date().toISOString() });
+
+    try {
+      // Ecriture note test
+      ensureDir(notesDir);
+      writeFileSync(testNoteFile, testPayload, 'utf-8');
+      const readBack = readFileSync(testNoteFile, 'utf-8');
+      noteWriteOk = readBack === testPayload;
+      unlinkSync(testNoteFile);
+
+      // Ecriture CR test
+      ensureDir(crDir);
+      writeFileSync(testCrFile, testPayload, 'utf-8');
+      const readBackCr = readFileSync(testCrFile, 'utf-8');
+      crWriteOk = readBackCr === testPayload;
+      unlinkSync(testCrFile);
+
+      // Nettoyage dossier agent test
+      const { resolveAgentDir } = await import('../../lib/core/notewriter/paths.js');
+      const agentDir = resolveAgentDir(root, testAgent);
+      const { rmSync } = await import('node:fs');
+      rmSync(agentDir, { recursive: true, force: true });
+
+      writeOk = noteWriteOk && crWriteOk;
+      cleanupOk = !existsSync(agentDir);
+    } catch {
+      writeOk = false;
+    }
+  }
+
+  // --- Affichage resultat complet ---
+  const lines = [
+    `Connexion : ${cx.name}`,
+    `Provider  : ${cx.provider}`,
+    `Modele    : ${result.model || cx.model || '(defaut)'}`,
+    `Latence   : ${result.latency}ms`,
+    '',
+    style.bold('1. Reponse LLM'),
+    `   ${result.response || '(vide)'}`,
+    `   ${style.green('\u2713')} Generation texte OK`,
+    '',
+    style.bold('2. Ecriture fichiers'),
+  ];
+
+  if (!project) {
+    lines.push(`   ${style.dim('\u25CB')} Aucun projet detecte — test ecriture ignore`);
+  } else {
+    lines.push(noteWriteOk
+      ? `   ${style.green('\u2713')} Ecriture note : creation + lecture + suppression OK`
+      : `   ${style.red('\u2717')} Ecriture note : echec`);
+    lines.push(crWriteOk
+      ? `   ${style.green('\u2713')} Ecriture CR   : creation + lecture + suppression OK`
+      : `   ${style.red('\u2717')} Ecriture CR   : echec`);
+    lines.push(cleanupOk
+      ? `   ${style.green('\u2713')} Nettoyage dossier test OK`
+      : `   ${style.dim('\u25CB')} Nettoyage partiel`);
+  }
+
+  lines.push('');
+  const allOk = result.ok && (!project || writeOk);
+  lines.push(allOk
+    ? `${style.green('\u2713')} Validation complete — connexion operationnelle`
+    : `${style.red('\u26A0')} Validation partielle — verifiez les erreurs ci-dessus`);
+
+  console.log('');
+  console.log(titledBox('Test reel — Resultat', lines, { border: allOk ? style.green : style.arkaRed }));
+  console.log('');
+}
+
+// ── connexions remove ───────────────────────────────────────────────
+
+async function handleConnexionsRemove(args, flags, config) {
+  const connexions = listConnexions();
+  if (connexions.length === 0) {
+    console.log(`\n  ${style.dim('Aucune connexion configuree.')}\n`);
+    return;
+  }
+
+  let cx = args[0] ? connexions.find(c => c.id === args[0] || c.name === args[0]) : null;
+  if (!cx) {
+    const selected = await pickFromList(
+      connexions.map(c => ({ id: c.id, title: c.provider, ...c })),
+      {
+        title: 'Supprimer quelle connexion ?',
+        labelFn: (c) => `${c.name} (${c.provider})`,
+      },
+    );
+    if (!selected) return;
+    cx = connexions.find(c => c.id === selected);
+  }
+  if (!cx) return;
+
+  const confirmed = await askConfirm(`Supprimer "${cx.name}" ?`, false);
+  if (!confirmed) { console.log('  Annule.\n'); return; }
+
+  removeConnexion(cx.id);
+
+  // Nettoyage references dans services.json
+  const project = await ensureProject(config, {}).catch(() => null);
+  if (project) {
+    const svcData = readServices(project.root || config.cwd);
+    let changed = false;
+    for (const [, svc] of Object.entries(svcData.services)) {
+      if (svc.connexion_id === cx.id) { svc.connexion_id = null; changed = true; }
+      if (svc.fallback) {
+        const before = svc.fallback.length;
+        svc.fallback = svc.fallback.filter(f => f.connexion_id !== cx.id);
+        if (svc.fallback.length !== before) changed = true;
+      }
+    }
+    if (changed) writeServices(project.root || config.cwd, svcData);
+  }
+
+  console.log(`  ${style.green('\u2713')} Connexion "${cx.name}" supprimee`);
+  console.log('');
+}
+
+// ── hooks ────────────────────────────────────────────────────────────
+
+async function handleHooks(args, flags, config) {
+  let sub = args[0];
+
+  if (!sub) {
+    sub = await interactiveMenu([
+      { label: 'status', value: 'status', description: 'Etat des hooks' },
+      { label: 'toggle', value: 'toggle', description: 'Activer/desactiver par hook' },
+      { label: 'setup',  value: 'setup',  description: 'Tout activer' },
+      { label: 'reset',  value: 'reset',  description: 'Tout desactiver' },
+      BACK_ITEM,
+      HOME_ITEM,
+    ], { title: 'Hooks Claude Code' });
+    if (!sub || sub === '__back__') return '__back__';
+    if (sub === '__home__') return '__home__';
+  }
+
+  switch (sub) {
+    case 'status': return handleHooksStatus(config);
+    case 'toggle': return handleHooksToggle(config);
+    case 'setup':  return handleHooksSetup(config);
+    case 'reset':  return handleHooksReset(config);
+  }
+}
+
+async function handleHooksStatus(config) {
+  const status = getHookStatus(config.cwd);
+  const hookNames = Object.keys(ALL_HOOKS);
+  const activeCount = hookNames.filter(h => status[h].active).length;
+
+  const lines = [];
+  for (const event of hookNames) {
+    const info = status[event];
+    const icon = info.active ? style.green('\u25CF') : style.dim('\u25CB');
+    const state = info.active ? 'actif' : 'inactif';
+    lines.push(`  ${icon} ${event.padEnd(20)} ${state.padEnd(8)} ${style.dim(info.command)}`);
+  }
+  lines.push('');
+  lines.push(activeCount === hookNames.length
+    ? style.green(`${activeCount}/${hookNames.length} hooks actifs`)
+    : `${activeCount}/${hookNames.length} hooks actifs`);
+
+  console.log('');
+  console.log(titledBox('Hooks Claude Code', lines, { border: style.nemesisAccent }));
+  console.log('');
+}
+
+async function handleHooksToggle(config) {
+  const hookNames = Object.keys(ALL_HOOKS);
+
+  while (true) {
+    const status = getHookStatus(config.cwd);
+    const items = hookNames.map(event => {
+      const info = status[event];
+      const icon = info.active ? style.green('\u25CF') : style.dim('\u25CB');
+      const state = info.active ? 'actif' : 'inactif';
+      return {
+        label: `${icon} ${event}`,
+        value: event,
+        description: `${state} — ${info.command}`,
+      };
+    });
+    items.push(
+      { label: 'Tout activer',     value: '__setup__',  description: '' },
+      { label: 'Tout desactiver',  value: '__reset__',  description: '' },
+      BACK_ITEM,
+      HOME_ITEM,
+    );
+
+    const choice = await interactiveMenu(items, { title: 'Toggle hooks' });
+    if (!choice || choice === '__back__') return;
+    if (choice === '__home__') return '__home__';
+
+    if (choice === '__setup__') {
+      await handleHooksSetup(config);
+      continue;
+    }
+    if (choice === '__reset__') {
+      await handleHooksReset(config);
+      continue;
+    }
+
+    // Toggle single hook
+    const info = status[choice];
+    const result = info.active
+      ? deactivateSingleHook(config.cwd, choice)
+      : activateSingleHook(config.cwd, choice);
+
+    if (result.ok) {
+      console.log(`  ${style.green('\u2713')} ${choice} ${info.active ? 'desactive' : 'active'}`);
+    } else {
+      console.log(`  ${style.red('\u2717')} Echec : ${result.error}`);
+    }
+  }
+}
+
+async function handleHooksSetup(config) {
+  const statusBefore = getHookStatus(config.cwd);
+  const alreadyActive = Object.values(statusBefore).filter(h => h.active).length;
+
+  installHooks(config.cwd);
+
+  const statusAfter = getHookStatus(config.cwd);
+  const nowActive = Object.values(statusAfter).filter(h => h.active).length;
+  const activated = nowActive - alreadyActive;
+
+  for (const [event, info] of Object.entries(statusAfter)) {
+    console.log(`  ${style.green('\u2713')} ${event} — ${info.active ? 'actif' : 'inactif'}`);
+  }
+  console.log('');
+  console.log(`  ${style.bold('Bilan :')} ${activated} actives, ${alreadyActive} deja actifs`);
+  console.log('');
+}
+
+async function handleHooksReset(config) {
+  const statusBefore = getHookStatus(config.cwd);
+  const wasActive = Object.values(statusBefore).filter(h => h.active).length;
+  const wasInactive = Object.values(statusBefore).filter(h => !h.active).length;
+
+  removeHooks(config.cwd);
+
+  for (const [event] of Object.entries(ALL_HOOKS)) {
+    console.log(`  ${style.dim('\u25CB')} ${event} — inactif`);
+  }
+  console.log('');
+  console.log(`  ${style.bold('Bilan :')} ${wasActive} desactives, ${wasInactive} deja inactifs`);
+  console.log('');
+}
+
+// ── config ──────────────────────────────────────────────────────────
+
+async function handleConfig(args, flags, config) {
+  const project = await ensureProject(config, flags);
+  if (!project) return;
+
+  let serviceId = args[0];
+  if (!serviceId) {
+    const items = SERVICE_IDS.map(id => ({
+      label: id, value: id, description: SERVICE_LABELS[id],
+    }));
+    items.push(BACK_ITEM, HOME_ITEM);
+    serviceId = await interactiveMenu(items, { title: 'Configurer quel service ?' });
+    if (!serviceId || serviceId === '__back__') return '__back__';
+    if (serviceId === '__home__') return '__home__';
+  }
+  if (!SERVICE_IDS.includes(serviceId)) {
+    console.log(`  Service inconnu : ${serviceId}`);
+    return;
+  }
+  return configureService(serviceId, project, flags, config);
+}
+
+async function configureService(serviceId, project, flags, config) {
+  const connexions = listConnexions();
+  if (connexions.length === 0) {
+    console.log(`\n  ${style.dim('Aucune connexion. Creez-en une d\'abord :')}`);
+    console.log(`  nemesis services connexions add\n`);
+    return;
+  }
+  console.log(`\n  Service : ${style.bold(SERVICE_LABELS[serviceId])}\n`);
+
+  // Connexion primaire
+  const primaryItems = connexions.map(c => ({
+    label: `${c.name}  (${c.provider}${c.model ? ' \u2014 ' + c.model : ''})`,
+    value: c.id, description: '',
+  }));
+  const primaryId = await interactiveMenu(primaryItems, { title: 'Connexion primaire' });
+  if (!primaryId) return;
+
+  // Model override
+  const modelOverride = await askText('Modele override (laisser vide pour celui de la connexion)', '');
+
+  // Strategie fallback
+  const fbCountItems = [
+    { label: 'Aucun fallback', value: '0', description: '' },
+    { label: '1 fallback',     value: '1', description: '' },
+    { label: '2 fallbacks',    value: '2', description: '' },
+  ];
+  const fbCount = await interactiveMenu(fbCountItems, { title: 'Strategie de fallback' });
+  if (!fbCount) return;
+
+  const fallback = [];
+  const remaining = connexions.filter(c => c.id !== primaryId);
+  for (let i = 0; i < parseInt(fbCount); i++) {
+    const avail = remaining.filter(c => !fallback.some(f => f.connexion_id === c.id));
+    if (avail.length === 0) break;
+    const fbItems = avail.map(c => ({
+      label: `${c.name}  (${c.provider}${c.model ? ' \u2014 ' + c.model : ''})`,
+      value: c.id, description: '',
+    }));
+    const fbId = await interactiveMenu(fbItems, { title: `Fallback ${i + 1}` });
+    if (!fbId) break;
+    const defaults = SERVICE_DEFAULTS[serviceId] || { fallback_timeout: 3 };
+    fallback.push({ connexion_id: fbId, timeout: defaults.fallback_timeout });
+  }
+
+  // Persister
+  assignService(project.root || config.cwd, serviceId, {
+    connexionId: primaryId, modelOverride: modelOverride || null, fallback,
+  });
+
+  // Confirmation
+  const primaryName = connexions.find(c => c.id === primaryId)?.name || primaryId;
+  console.log(`\n  ${style.green('\u2713')} Service ${serviceId} configure`);
+  console.log(`     Primaire  \u2192 ${primaryName}`);
+  for (let i = 0; i < fallback.length; i++) {
+    const fbName = connexions.find(c => c.id === fallback[i].connexion_id)?.name || '?';
+    console.log(`     Fallback ${i + 1} \u2192 ${fbName}`);
+  }
+  console.log('');
+}
+
+// ── status ──────────────────────────────────────────────────────────
+
+async function handleStatus(args, flags, config) {
+  const project = await ensureProject(config, flags);
+  if (!project) return;
+
+  const svcData = readServices(project.root || config.cwd);
+  const connexions = listConnexions();
+
+  if (Object.keys(svcData.services).length === 0) {
+    console.log(`\n  ${style.dim('Aucun service configure.')}`);
+    console.log(`  ${style.dim('Utilisez')} nemesis services config\n`);
+    return;
+  }
+
+  const lines = [];
+  for (const sid of SERVICE_IDS) {
+    const svc = svcData.services[sid];
+    if (!svc) {
+      lines.push(`${style.bold(SERVICE_LABELS[sid])}`);
+      lines.push(`  ${style.dim('\u25CB')} non configure`);
+      lines.push('');
+      continue;
+    }
+
+    lines.push(`${style.bold(SERVICE_LABELS[sid])}`);
+
+    // Primaire
+    const primary = connexions.find(c => c.id === svc.connexion_id);
+    if (primary) {
+      const statusIcon = primary.status === 'connected'
+        ? style.green('\u25CF')
+        : primary.status === 'error'
+          ? style.red('\u25CF')
+          : style.dim('\u25CB');
+      const tested = primary.last_tested
+        ? new Date(primary.last_tested).toLocaleDateString('fr-FR') + ' ' +
+          new Date(primary.last_tested).toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit' })
+        : '';
+      lines.push(`  Primaire   ${primary.name}  ${statusIcon} ${primary.status}  ${style.dim(tested)}`);
+    } else {
+      lines.push(`  Primaire   ${style.red('connexion manquante')}`);
+    }
+
+    // Fallbacks
+    for (let i = 0; i < (svc.fallback || []).length; i++) {
+      const fb = svc.fallback[i];
+      const fbCx = connexions.find(c => c.id === fb.connexion_id);
+      if (fbCx) {
+        const fbIcon = fbCx.status === 'connected'
+          ? style.green('\u25CF')
+          : fbCx.status === 'error'
+            ? style.red('\u25CF')
+            : style.dim('\u25CB');
+        lines.push(`  Fallback   ${fbCx.name}  ${fbIcon} ${fbCx.status}`);
+      }
+    }
+    lines.push('');
+  }
+
+  console.log('');
+  console.log(titledBox('Services LLM', lines, { border: style.nemesisAccent }));
+  console.log('');
+}