brainclaw 1.20.4 → 1.22.0

package/dist/cli/register-cloud.js

@@ -0,0 +1,63 @@
+import { runCloudStatus, runCloudConnect, runCloudAwait, runCloudDisconnect, } from '../commands/cloud.js';
+/** Adresse du cloud. Fournie par `--url`, sans quoi la commande demande de la préciser. */
+const DEFAULT_URL_HINT = 'https://<votre-déploiement>.workers.dev';
+function fail(message) {
+    console.error(message);
+    process.exit(1);
+}
+/**
+ * Fédération v2 (pln#651 étapes 3 et 4).
+ *
+ * `connect` est une CÉRÉMONIE DE CLÉS, pas une écriture de configuration — voir
+ * src/core/federation-pairing.ts. L'humain ne manipule qu'un code d'invitation et compare
+ * deux empreintes ; aucune clé d'API, aucun PEM, aucune variable d'environnement (dec#8).
+ */
+export function registerCloudCommands(program) {
+    const cloud = program
+        .command('cloud')
+        .description('Fédération cloud v2 : appairage attesté, état de connexion, epochs de clés');
+    cloud
+        .command('status')
+        .description("Affiche le projet lié, le rôle, l'epoch de clé courant et les trois états de sync")
+        .option('--json', 'Sortie JSON')
+        .action((options) => {
+        runCloudStatus({ json: options.json });
+    });
+    cloud
+        .command('connect <invite-code>')
+        .description("Rejoint un projet cloud : réclame l'invitation, prouve la possession de l'identité et atteste la clé de chiffrement de cet appareil")
+        .requiredOption('--url <url>', `Adresse du déploiement cloud (ex. ${DEFAULT_URL_HINT})`)
+        .requiredOption('--agent <id>', "Identifiant d'agent à enrôler (opaque, 4 à 64 caractères)")
+        .option('--json', 'Sortie JSON')
+        .action(async (inviteCode, options) => {
+        await runCloudConnect({
+            inviteCode,
+            url: options.url,
+            agentId: options.agent,
+            json: options.json,
+        }).catch((err) => fail(`Erreur : ${err instanceof Error ? err.message : String(err)}`));
+    });
+    cloud
+        .command('await')
+        .description("Constate l'approbation humaine et active l'appairage local")
+        // Commande DISTINCTE de connect : l'approbation dépend d'un humain dont le délai
+        // n'est pas borné. Bloquer indéfiniment sur un tiers ferait un mauvais citoyen dans
+        // un script, et une interruption doit rester reprenable.
+        .requiredOption('--url <url>', 'Adresse du déploiement cloud')
+        .action(async (options) => {
+        await runCloudAwait({ url: options.url })
+            .catch((err) => fail(`Erreur : ${err instanceof Error ? err.message : String(err)}`));
+    });
+    cloud
+        .command('disconnect')
+        .description("Retire l'autorisation locale et demande la révocation distante")
+        .requiredOption('--url <url>', 'Adresse du déploiement cloud')
+        // Effacer le trousseau rend DÉFINITIVEMENT illisible tout ce qui a été scellé sous
+        // ces epochs. Ce n'est donc pas le défaut : on le demande explicitement.
+        .option('--forget-keys', "Efface aussi les clés d'epoch de ce projet (le passé scellé devient illisible ici)")
+        .action(async (options) => {
+        await runCloudDisconnect({ url: options.url, forgetKeys: options.forgetKeys })
+            .catch((err) => fail(`Erreur : ${err instanceof Error ? err.message : String(err)}`));
+    });
+}
+//# sourceMappingURL=register-cloud.js.map

package/dist/cli.js

@@ -13,8 +13,8 @@ import { registerPlanningCommands } from './cli/register-planning.js';
 import { registerCoordinationCommands } from './cli/register-coordination.js';
 import { registerReviewCommands } from './cli/register-review.js';
 import { registerMemoryContextCommands } from './cli/register-memory-context.js';
-import { registerFederationCommands } from './cli/register-federation.js';
 import { registerCodeMapCommands } from './cli/register-code-map.js';
+import { registerCloudCommands } from './cli/register-cloud.js';
 const program = new Command();
 function parseLeadingGlobalOptions(argv) {
     const result = {};
@@ -171,8 +171,8 @@ registerPlanningCommands(program);
 registerCoordinationCommands(program);
 registerReviewCommands(program);
 registerMemoryContextCommands(program);
-registerFederationCommands(program);
 registerCodeMapCommands(program);
+registerCloudCommands(program);
 // ─── Command-order shim (pln#622 PR5) ────────────────────────────────────────
 // Commander renders `--help` in registration order. The per-family register
 // modules above would otherwise reorder the help output relative to the
@@ -290,7 +290,6 @@ const ORIGINAL_COMMAND_ORDER = [
     'switch',
     'who',
     'worktree',
-    'federation',
     // Gated by BRAINCLAW_ENABLE_CODEV: listed here so the order is right in both
     // modes — when not registered they are simply absent from the live array and
     // the sort skips them naturally.

package/dist/commands/cloud.js

@@ -0,0 +1,198 @@
+/**
+ * `brainclaw cloud connect / status / disconnect` — fédération v2 (pln#651 étapes 3 et 4).
+ *
+ * `connect` n'est pas une écriture de configuration : c'est une CÉRÉMONIE DE CLÉS. Elle
+ * réclame une invitation, prouve la possession de l'identité Ed25519, atteste la clé de
+ * chiffrement X25519 de l'appareil, puis attend une approbation humaine qui compare des
+ * empreintes. Ce qui la rend indissociable de la distribution des clés est écrit dans
+ * src/core/federation-pairing.ts.
+ *
+ * L'HUMAIN NE COPIE QU'UN CODE D'INVITATION, et compare deux empreintes. Aucune clé
+ * d'API, aucun PEM, aucun agent_id, aucune variable d'environnement (dec#8).
+ *
+ * dec#154 exige que l'état de sync soit VISIBLE : un état pending/synced/conflict que seul
+ * le code consulte transformerait le relais cloud en autorité silencieuse. C'est ce que
+ * `status` rend.
+ */
+import { summarizeConnection, loadConnectionState, saveConnectionState } from '../core/federation-state.js';
+import { forgetProjectEpochs } from '../core/federation-keyring.js';
+import { beginPairing, checkPairingApproval, completePairing, requestRevocation, PairingError, } from '../core/federation-pairing.js';
+import { resolveEffectiveCwd } from '../core/store-resolution.js';
+import { nowISO } from '../core/ids.js';
+export function runCloudStatus(options = {}) {
+    const cwd = options.cwd ?? resolveEffectiveCwd();
+    const summary = summarizeConnection(cwd);
+    if (options.json) {
+        console.log(JSON.stringify(summary, null, 2));
+        return;
+    }
+    if (summary.stage === 'unpaired') {
+        console.log('Cloud : non appairé.');
+        console.log("  Aucun sync n'a lieu tant qu'aucun appairage n'a été fait explicitement.");
+        // Énoncé volontairement, parce que c'est le défaut que la v2 ferme : en v1 la seule
+        // présence de BRAINCLAW_CLOUD_API_KEY valait consentement, et jusqu'à 100 signaux
+        // étaient tirés puis écrits dans le store local à chaque démarrage de session.
+        return;
+    }
+    console.log(`Cloud : ${summary.stage}${summary.connected ? '' : ' (pas encore actif)'}`);
+    console.log(`  Projet   : ${summary.cloud_project_id ?? '—'}`);
+    console.log(`  Rôle     : ${summary.role ?? '—'}`);
+    console.log(`  Appareil : ${summary.device_fingerprint?.slice(0, 16) ?? '—'}…`);
+    console.log(`  Epoch    : ${summary.current_epoch} (lisibles : ${summary.readable_epochs.join(', ') || 'aucun'})`);
+    console.log(`  Sync     : ${summary.sync.pending} en attente · ${summary.sync.synced} synchronisé(s) · ${summary.sync.conflict} conflit(s)`);
+    if (summary.last_pull_at)
+        console.log(`  Dernier pull : ${summary.last_pull_at}`);
+    if (!summary.recovery.ready) {
+        console.log('');
+        console.log(`  ⚠ Récupération : ${summary.recovery.reason}`);
+    }
+    if (summary.sync.conflict > 0) {
+        console.log('');
+        // Un conflit ne se résout JAMAIS par last-write-wins silencieux (dec#154) : il est
+        // présenté, avec une proposition, et attend une décision.
+        console.log(`  ${summary.sync.conflict} opération(s) en conflit attendent une résolution explicite.`);
+    }
+}
+// ── Transport HTTP ────────────────────────────────────────────────────────────
+/**
+ * Transport réel. Injecté partout ailleurs pour que la cérémonie soit exerçable sans
+ * réseau — les tests font tourner un cloud simulé qui VÉRIFIE réellement les signatures,
+ * ce qu'un serveur acceptant tout ne prouverait pas.
+ */
+export function httpTransport(baseUrl) {
+    const url = (p) => `${baseUrl.replace(/\/+$/, '')}${p}`;
+    const call = async (method, path, body) => {
+        const res = await fetch(url(path), {
+            method,
+            headers: { 'Content-Type': 'application/json' },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        // Une réponse non-JSON (page d'erreur de proxy, 502 HTML) ne doit pas lever une
+        // exception de parsing qui masquerait le vrai statut HTTP — c'est lui qui porte
+        // l'information utile.
+        let parsed = {};
+        try {
+            parsed = (await res.json());
+        }
+        catch { /* corps non-JSON */ }
+        return { status: res.status, body: parsed };
+    };
+    return {
+        post: (path, body) => call('POST', path, body),
+        get: (path) => call('GET', path),
+    };
+}
+export async function runCloudConnect(options) {
+    const cwd = options.cwd ?? resolveEffectiveCwd();
+    const transport = options.transport ?? httpTransport(options.url);
+    let handle;
+    try {
+        handle = await beginPairing({
+            inviteCode: options.inviteCode,
+            agentId: options.agentId,
+            transport,
+            cwd,
+        });
+    }
+    catch (err) {
+        if (err instanceof PairingError) {
+            console.error(`Appairage interrompu à l'étape « ${err.stage} » : ${err.message}`);
+            // Fail-closed : un appairage refusé ne laisse aucune trace locale, donc relancer la
+            // commande est sûr et ne laisse pas d'orphelin à nettoyer.
+            process.exitCode = 1;
+            return;
+        }
+        throw err;
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            enrollment_id: handle.enrollment_id,
+            cloud_project_id: handle.cloud_project_id,
+            device_id: handle.device.device_id,
+            fingerprints: handle.fingerprints,
+            awaiting: 'human_approval',
+        }, null, 2));
+        return;
+    }
+    console.log('Preuve de possession acceptée. Attestation de clé enregistrée.');
+    console.log('');
+    console.log('  Projet cloud : ' + handle.cloud_project_id);
+    console.log('  Enrôlement   : ' + handle.enrollment_id);
+    console.log('');
+    // CES DEUX EMPREINTES SONT LE CŒUR DE LA CÉRÉMONIE. La personne qui approuve voit les
+    // mêmes à l'écran ; leur comparaison hors bande est ce qui ferme l'attaque de l'homme
+    // du milieu sur l'appairage. Affichées EN ENTIER, pas tronquées : une comparaison sur
+    // 16 caractères se collisionne bien plus facilement qu'elle n'en a l'air.
+    console.log("  Empreinte d'identité     (Ed25519) : " + handle.fingerprints.identity);
+    console.log('  Empreinte de chiffrement (X25519)  : ' + handle.fingerprints.encryption);
+    console.log('');
+    console.log('  → Faites vérifier CES DEUX EMPREINTES par la personne qui approuve.');
+    console.log("    Si elles diffèrent de ce qu'elle voit, REFUSEZ : quelqu'un s'est interposé.");
+    console.log('');
+    console.log("  En attente d'approbation humaine. Constatez-la avec : brainclaw cloud await");
+}
+/**
+ * Constate l'approbation et bascule l'état local en actif.
+ *
+ * SÉPARÉ DE `connect` : l'approbation dépend d'un humain, dont le délai n'est pas borné.
+ * Une commande qui bloquerait indéfiniment sur un tiers serait un mauvais citoyen dans un
+ * script, et un appairage interrompu par un Ctrl-C doit rester reprenable.
+ */
+export async function runCloudAwait(options) {
+    const cwd = options.cwd ?? resolveEffectiveCwd();
+    const state = loadConnectionState(cwd);
+    if (!state?.enrollment.enrollment_id) {
+        console.error("Aucun appairage en cours sur ce workspace. Lancez d'abord : brainclaw cloud connect");
+        process.exitCode = 1;
+        return;
+    }
+    const transport = options.transport ?? httpTransport(options.url);
+    const result = await checkPairingApproval({ enrollmentId: state.enrollment.enrollment_id, transport, cwd });
+    if (!result.approved) {
+        console.log(`Toujours en attente (état distant : ${result.state}).`);
+        return;
+    }
+    const next = completePairing({ role: result.role, cwd });
+    console.log(`Appairage approuvé. Rôle : ${next.enrollment.role ?? '—'}.`);
+    console.log('');
+    // Le premier pull est en LECTURE SEULE et non destructif (RFC §5.2 phase 4) : rien
+    // n'est matérialisé dans la mémoire locale tant que la vérification d'origine n'existe
+    // pas. Le dire évite qu'on croie la synchronisation déjà active.
+    console.log("  Aucune donnée n'est encore matérialisée : la vérification à la réception");
+    console.log("  (signature d'origine, anti-rejeu) est livrée à l'étape suivante.");
+}
+export async function runCloudDisconnect(options) {
+    const cwd = options.cwd ?? resolveEffectiveCwd();
+    const state = loadConnectionState(cwd);
+    if (!state) {
+        console.log("Ce workspace n'est pas appairé — rien à déconnecter.");
+        return;
+    }
+    let revocationNote = "aucune révocation distante demandée (pas d'enrôlement connu)";
+    if (state.enrollment.enrollment_id) {
+        const transport = options.transport ?? httpTransport(options.url);
+        const res = await requestRevocation({ enrollmentId: state.enrollment.enrollment_id, transport });
+        revocationNote = res.revoked
+            ? 'autorisation distante révoquée'
+            : `révocation distante NON confirmée (${res.detail ?? 'raison inconnue'})`;
+    }
+    // L'état local passe en 'revoked' MÊME SI le cloud est injoignable : sinon un appareil
+    // perdu resterait autorisé faute de réseau, exactement l'inverse de ce qu'une
+    // révocation doit garantir.
+    saveConnectionState({ ...state, enrollment: { ...state.enrollment, stage: 'revoked', updated_at: nowISO() } }, cwd);
+    let keysNote = "trousseau conservé (utilisez --forget-keys pour l'effacer)";
+    if (options.forgetKeys) {
+        const removed = forgetProjectEpochs(state.cloud_project_id);
+        keysNote = `${removed} clé(s) d'epoch effacée(s) — le passé scellé de ce projet devient illisible ici`;
+    }
+    console.log('Déconnecté.');
+    console.log(`  ${revocationNote}`);
+    console.log(`  ${keysNote}`);
+    console.log('');
+    // Énoncé plutôt que tu : prétendre l'inverse serait une promesse que la cryptographie
+    // ne tient pas (RFC §5.2).
+    console.log("  Ce qui N'EST PAS effacé : les données déjà tirées et déchiffrées localement,");
+    console.log("  et ce que d'autres appareils détiennent déjà. Un disconnect retire une");
+    console.log('  autorisation ; il ne réécrit pas le passé.');
+}
+//# sourceMappingURL=cloud.js.map

package/dist/commands/export.js

@@ -6,7 +6,7 @@ import { loadConfig, saveConfig } from '../core/config.js';
 import { isAgentIntegrationName, upsertAgentIntegrationDeclaration } from '../core/agent-integrations.js';
 import { resolveInstructions, loadInstructions } from '../core/instructions.js';
 import { detectAiAgent } from '../core/ai-agent-detection.js';
-import { AGENT_EXPORT_REGISTRY, resolveExportTarget, resolveExportTargetByFormat, resolveLiveCompanionPath, writeExportFile, writeLiveCompanionFile, buildHygieneSection, describeAutoConfigWrite, writeExportCompanionFiles, collectExportGitignoreEntries, ensureGitignoreEntries, BRAINCLAW_EXCLUSIVE_DIRECTORIES, } from '../core/agent-files.js';
+import { AGENT_EXPORT_REGISTRY, resolveExportTarget, resolveExportTargetByFormat, resolveLiveCompanionPath, writeExportFile, writeLiveCompanionFile, buildHygieneSection, describeAutoConfigWrite, writeExportCompanionFiles, collectExportGitignoreEntries, ensureGitignoreEntries, BRAINCLAW_EXCLUSIVE_DIRECTORIES, BRAINCLAW_PROTOCOL_ARTIFACT_IGNORES, } from '../core/agent-files.js';
 import { buildCoordinationSnapshot } from '../core/coordination.js';
 import { listClaims } from '../core/claims.js';
 import { listCandidates } from '../core/candidates.js';
@@ -61,7 +61,7 @@ export function runExport(options) {
         });
         if (liveResult)
             gitignoreEntries.push(liveResult.relativePath);
-        ensureGitignoreEntries(cwd, [...gitignoreEntries, ...BRAINCLAW_EXCLUSIVE_DIRECTORIES]);
+        ensureGitignoreEntries(cwd, [...gitignoreEntries, ...BRAINCLAW_EXCLUSIVE_DIRECTORIES, ...BRAINCLAW_PROTOCOL_ARTIFACT_IGNORES]);
         declareAgentIntegrationFromTarget(cwd, target.agentName, 'manual');
         console.log(`✔ Written to ${target.relativePath} (${result.created ? 'created' : 'updated'})`);
         if (liveResult) {
@@ -102,7 +102,7 @@ function runExportDetect(cwd, options) {
     const gitignoreEntries = collectExportGitignoreEntries(cwd, target.relativePath, autoConfigs);
     if (liveResult)
         gitignoreEntries.push(liveResult.relativePath);
-    ensureGitignoreEntries(cwd, [...gitignoreEntries, ...BRAINCLAW_EXCLUSIVE_DIRECTORIES]);
+    ensureGitignoreEntries(cwd, [...gitignoreEntries, ...BRAINCLAW_EXCLUSIVE_DIRECTORIES, ...BRAINCLAW_PROTOCOL_ARTIFACT_IGNORES]);
     declareAgentIntegrationFromTarget(cwd, target.agentName, detected ? 'detected' : 'manual');
     const source = detected ? `${detected.name} [${detected.detection_source}]` : 'fallback (no agent detected)';
     console.log(`✔ Detected: ${source}`);

package/dist/commands/init.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import readline from 'node:readline/promises';
+import { clearEnumerationMemo } from '../core/entity-locator.js';
 import { registerAgentIdentity, resolveDefaultAgentName, resolveExistingCurrentAgent } from '../core/agent-registry.js';
 import { MEMORY_DIR, memoryExists, ensureMemoryDir, memoryPath, writeFileAtomic } from '../core/io.js';
 import { emptyState, loadState, saveState } from '../core/state.js';
@@ -371,6 +372,16 @@ export async function runInit(options = {}) {
         console.log(`Tip: run 'brainclaw init' again later to refresh the detected agent's integration files on this project.`);
     }
     console.log(`Tip: in an agent session, call the bclaw_work MCP tool (intent: "consult") to load the shared memory; from a terminal, 'brainclaw context --json' does the same.`);
+    // A STORE JUST CAME INTO EXISTENCE, so the routing memo's candidate list is stale.
+    //
+    // `clearEnumerationMemo` was documented as being "for tests, and for any caller that has
+    // just created a store" — and that second caller did not exist (Fable audit found the
+    // claim describing intent rather than code). The consequence was small but real: for up
+    // to the memo TTL, a mutation routed right after `brainclaw init` / `bclaw_init_project`
+    // could not see the new project. Wiring it HERE rather than in the MCP handler covers
+    // every path that materialises a store, since both the CLI and the tool go through
+    // runInit.
+    clearEnumerationMemo();
 }
 function safeRunMachinePrereqs(agentName) {
     try {