brainclaw 1.21.0 → 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/session-end.js

@@ -28,7 +28,6 @@ import { loadState, persistState } from '../core/state.js';
 import { listArchivedCandidates, listCandidates } from '../core/candidates.js';
 import { createFederationMessage } from '../core/federation-message.js';
 import { pushSignal } from '../core/federation-transport.js';
-import { pushSignalToCloud, isCloudSyncEnabled } from '../core/federation-cloud.js';
 import { loadConfig } from '../core/config.js';
 import { resolveCrossProjectLinks } from '../core/cross-project.js';
 import { createCandidateFromInput } from './reflect.js';
@@ -351,24 +350,6 @@ export async function endSession(options = {}) {
     if (pushedSignals > 0 && !options.json) {
         console.log(`✔ Pushed ${pushedSignals} signal(s) to linked projects`);
     }
-    // Cloud federation push (Phase 1 — opt-in via cloud_sync.enabled)
-    let pushedCloudSignals = 0;
-    if (isCloudSyncEnabled(options.cwd)) {
-        try {
-            pushedCloudSignals = await pushSessionCloudSignals({
-                sessionId,
-                actor,
-                sessionNotes,
-                cwd: options.cwd,
-            });
-        }
-        catch {
-            // Non-fatal — cloud push failure should not block session end
-        }
-    }
-    if (pushedCloudSignals > 0 && !options.json) {
-        console.log(`✔ Pushed ${pushedCloudSignals} signal(s) to cloud`);
-    }
     appendAuditEntry({
         action: 'session_end',
         actor: actor.agent,
@@ -509,89 +490,6 @@ function pushSessionFederationSignals(input) {
     }
     return pushed;
 }
-/**
- * Push session-scoped handoffs / candidates / runtime_notes to the cloud federation.
- * Skips entities with visibility = 'machine' or 'private' — only 'shared' (default) goes out.
- * Failures per-entity are swallowed so a single bad fetch does not abort the rest.
- */
-async function pushSessionCloudSignals(input) {
-    const cwd = input.cwd ?? process.cwd();
-    const config = loadConfig(cwd);
-    const fromProjectName = config.project_name ?? path.basename(cwd);
-    const currentState = loadState(cwd);
-    const sessionHandoffs = currentState.open_handoffs.filter((handoff) => handoff.session_id === input.sessionId);
-    const sessionCandidates = [
-        ...listCandidates(undefined, cwd),
-        ...listArchivedCandidates('accepted', cwd),
-        ...listArchivedCandidates('rejected', cwd),
-    ].filter((candidate) => candidate.session_id === input.sessionId);
-    const sessionRuntimeNotes = input.sessionNotes.filter((note) => note.session_id === input.sessionId);
-    // Conservative cloud-push gate (review finding 2026-05-15, finalized via
-    // pln#365 finalization 2026-05-15):
-    //
-    // All four signal-bearing schemas now carry a `visibility` field:
-    //   - RuntimeNoteSchema  (schema.ts:899)  — defaults to 'shared'
-    //   - TrapSchema         (schema.ts:184)  — defaults to 'shared'
-    //   - HandoffSchema      (schema.ts:~248) — optional, no default (opt-in)
-    //   - CandidateSchema    (schema.ts:~619) — optional, no default (opt-in)
-    //
-    // Handoffs and candidates are opt-in because their text / snapshot.diff
-    // can carry per-host secrets. An agent must explicitly set
-    // `visibility: 'shared'` to push such an entity to cloud. RuntimeNotes
-    // default to shared since they're already the lightest-weight signal.
-    //
-    // The gate below is intentionally literal — `entity.visibility === 'shared'`.
-    // Undefined or absent visibility means "stay local" regardless of cloud_sync.
-    const isExplicitlyShared = (entity) => {
-        return entity.visibility === 'shared';
-    };
-    let pushed = 0;
-    const pushOne = async (entityType, entity) => {
-        const message = createFederationMessage({
-            version: 1,
-            from: {
-                project_id: input.actor.project_id ?? config.project_id,
-                project_name: fromProjectName,
-                project_path: cwd,
-                agent_name: input.actor.agent,
-                agent_id: input.actor.agent_id,
-                host_id: input.actor.host_id,
-            },
-            to: {
-                // Cloud is a broadcast bus — no specific target project at this layer.
-                project_name: 'broadcast',
-                project_path: '',
-            },
-            type: entityType,
-            payload: entity,
-            causal_parent: input.sessionId,
-        });
-        try {
-            const ok = await pushSignalToCloud(message, cwd);
-            if (ok)
-                pushed++;
-        }
-        catch {
-            // Per-entity failure should not abort the loop
-        }
-    };
-    for (const handoff of sessionHandoffs) {
-        if (!isExplicitlyShared(handoff))
-            continue;
-        await pushOne('handoff', handoff);
-    }
-    for (const candidate of sessionCandidates) {
-        if (!isExplicitlyShared(candidate))
-            continue;
-        await pushOne('candidate', candidate);
-    }
-    for (const note of sessionRuntimeNotes) {
-        if (!isExplicitlyShared(note))
-            continue;
-        await pushOne('runtime_note', note);
-    }
-    return pushed;
-}
 function resolvePublisherLink(target, publisherLinks, entityType, cwd) {
     const normalized = target.trim().toLowerCase();
     if (!normalized)

package/dist/commands/session-start.js

@@ -24,7 +24,6 @@ import { toWarningDetail } from '../core/warnings.js';
 import { loadHygienePolicy } from '../core/hygiene-policy.js';
 import { maybeCreateCheckpoint } from '../core/events/checkpoint.js';
 import { pullSignalsFromLinkedProjects, markSignalProcessed } from '../core/federation-transport.js';
-import { pullSignalsFromCloud, isCloudSyncEnabled } from '../core/federation-cloud.js';
 import { materializeFederationSignal } from '../core/federation-materialize.js';
 function sessionsDir(cwd) {
     return resolveEntityDir('sessions', cwd ?? process.cwd(), 'read');
@@ -340,28 +339,6 @@ export async function startSession(options = {}) {
         }
         catch { /* Non-fatal — federation pull failure should not block session start */ }
     }
-    // Materialize incoming federation signals from cloud (Phase 1 — opt-in via cloud_sync.enabled)
-    if (maintenanceMode === 'full' && isCloudSyncEnabled(options.cwd)) {
-        try {
-            const cloudSignals = await pullSignalsFromCloud(actor.agent, { limit: 100 }, options.cwd);
-            let cloudMaterialized = 0;
-            for (const signal of cloudSignals) {
-                try {
-                    if (materializeFederationSignal(signal, options.cwd)) {
-                        cloudMaterialized++;
-                    }
-                    // No markSignalProcessed for cloud signals — cloud-side tracks delivery via the
-                    // inbox endpoint's own state (per-agent read cursor). If the cloud returns the
-                    // same signal twice, the idempotency_key field allows future dedup at materialize time.
-                }
-                catch { /* skip this signal — do not block session start */ }
-            }
-            if (cloudMaterialized > 0) {
-                console.log(`✔ Materialized ${cloudMaterialized} federation signal(s) from cloud`);
-            }
-        }
-        catch { /* Non-fatal — cloud pull failure should not block session start */ }
-    }
     return {
         ...snapshot,
         ...(agentGitHygiene.isGitRepo && (agentGitHygiene.missingGitignorePaths.length > 0 || agentGitHygiene.trackedPaths.length > 0)

package/dist/core/claims.js

@@ -16,7 +16,6 @@ import { loadState, persistState } from './state.js';
 import { createRuntimeEvent } from './events.js';
 import { latestActivityMs, readHeartbeat } from './runtime-signals.js';
 import { emitRegistryPostImage, registryFaultPoint } from './events/registry-post-image.js';
-import { maybeEnqueueClaimTransition, isFederationEnqueueActive } from './federation-outbox.js';
 /** Parse duration string like '4h', '30m' to ms. */
 function parseTtl(value) {
     const match = /^(\d+)([mhd])$/i.exec(value.trim());
@@ -79,26 +78,9 @@ function saveClaimUnlocked(claim, cwd, options) {
     // pln#568 (I2): journal the post-image BEFORE the projection write, so a
     // crash can only leave the journal ahead of the projection, never behind.
     const created = !store.exists(parsed.id);
-    // Federation (pln#101): capture the PREVIOUS status BEFORE the write so we can
-    // diff it after (create or active↔terminal transition ⇒ enqueue for cloud
-    // sync). Only pay the prev-load when federation is actually active; this whole
-    // block runs under the store mutation mutex, which serializes rev reservation.
-    const fedActive = isFederationEnqueueActive(cwd, options?.federation?.suppressEnqueue);
-    let fedPrevStatus;
-    if (fedActive) {
-        try {
-            fedPrevStatus = loadClaimFromAnyDir(parsed.id, cwd).status;
-        }
-        catch {
-            fedPrevStatus = undefined;
-        }
-    }
     emitRegistryPostImage('claim', parsed, { created, agent: parsed.agent, agent_id: parsed.agent_id, session_id: parsed.session_id, cwd });
     registryFaultPoint('after_registry_journal');
     store.save(parsed);
-    if (fedActive) {
-        maybeEnqueueClaimTransition(parsed, fedPrevStatus, fedPrevStatus === undefined, cwd, options?.federation?.suppressEnqueue);
-    }
     const writeDir = claimsDir(cwd, 'write');
     for (const dirPath of claimDirs(cwd)) {
         if (dirPath === writeDir)

package/dist/core/coordination.js

@@ -300,9 +300,7 @@ function buildIncomingSignalsSummary(cwd) {
     try {
         const fedSignals = pullSignalsFromLinkedProjects(cwd);
         for (const sig of fedSignals) {
-            const payloadPreview = typeof sig.payload === 'string'
-                ? sig.payload.slice(0, 120)
-                : JSON.stringify(sig.payload).slice(0, 120);
+            const payloadPreview = JSON.stringify(sig.payload).slice(0, 120);
             incomingSignals.push({
                 id: sig.id,
                 entity_type: sig.type,

package/dist/core/federation-attestation.js

@@ -0,0 +1,96 @@
+/**
+ * Contrat d'attestation de clé, côté CLIENT (pln#651 étape 4, RFC §5.2).
+ *
+ * ── CE FICHIER A UN JUMEAU, ET C'EST DÉLIBÉRÉ ─────────────────────────────────
+ * Le même contrat existe côté Cloud dans `brainclaw-cloud/src/lib/attestation.ts`.
+ * Les deux DOIVENT produire octet pour octet la même chaîne : le CLI signe, le Worker
+ * vérifie. Ils ne peuvent pas partager un module — deux dépôts, deux runtimes (Node ici,
+ * Workers là-bas) — donc la duplication est assumée et le gel de la forme est verrouillé
+ * DES DEUX CÔTÉS par un test sur le littéral exact.
+ *
+ * Ce n'est pas une précaution théorique. La première livraison côté Cloud reconstruisait
+ * `created_at` avec l'horloge du serveur au moment de l'approbation : la signature portait
+ * sur d'autres octets que ceux vérifiés, et AUCUN appairage ne pouvait aboutir. Le défaut
+ * a survécu à un typecheck vert parce que rien n'exerçait les deux côtés ensemble.
+ *
+ * RÈGLE QUI EN DÉCOULE, valable au-delà de ce fichier : tout champ couvert par une
+ * signature doit venir du signataire, ou d'une valeur qu'il connaît déjà. Un champ que le
+ * vérificateur fabrique lui-même ne peut pas être signé.
+ */
+import crypto from 'node:crypto';
+/**
+ * Payload canonique de l'attestation.
+ *
+ * LA FORME EST GELÉE. Changer l'ordre des clés ou ajouter un champ invalide toutes les
+ * attestations déjà émises — ce qui est voulu, mais doit être un acte délibéré, jamais
+ * l'effet de bord d'une refactorisation. Le test de gel existe pour cela.
+ */
+export function attestationPayload(input) {
+    return JSON.stringify({
+        v: 1,
+        kind: 'brainclaw.federation.v2.key_attestation',
+        enrollment_id: input.enrollment_id,
+        project_id: input.project_id,
+        agent_id: input.agent_id,
+        key_type: input.key_type,
+        key_purpose: input.key_purpose,
+        key_fingerprint: input.key_fingerprint,
+        key_epoch: input.key_epoch,
+        created_at: input.created_at,
+    });
+}
+/**
+ * Empreinte canonique d'un PEM — MÊME RÈGLE que `fingerprintPublicKeyPem` d'agent-registry
+ * et que `fingerprintPem` côté Cloud.
+ *
+ * Le retrait des CR et le trim ne sont pas cosmétiques : le même PEM traversant un champ
+ * JSON ou un éditeur Windows ressort avec un CRLF ou un saut de ligne final. Sans
+ * canonicalisation, deux représentations de LA MÊME clé donnent deux empreintes
+ * différentes — et la comparaison locale↔distante, qui EST la preuve d'identité de la
+ * clé, échouerait sur une différence invisible à l'œil.
+ */
+export function fingerprintPem(pem) {
+    return crypto.createHash('sha256').update(pem.replace(/\r/g, '').trim()).digest('hex');
+}
+/**
+ * Signe des octets avec une clé privée Ed25519 au format PEM, en base64.
+ *
+ * Ed25519 ne prend pas d'algorithme de hachage séparé — d'où le `null` en premier
+ * argument, qui n'est pas un oubli : passer un digest ici lèverait.
+ */
+export function signEd25519(privateKeyPem, message) {
+    const key = crypto.createPrivateKey(privateKeyPem);
+    return crypto.sign(null, Buffer.from(message), key).toString('base64');
+}
+/**
+ * Construit et signe l'attestation liant la clé de chiffrement X25519 de l'appareil à son
+ * identité Ed25519.
+ *
+ * C'EST LA PIÈCE QUI EMPÊCHE LE MEMBRE FANTÔME. Sans elle, le Cloud — qui orchestre
+ * l'appairage — pourrait insérer sa propre clé dans la liste d'enveloppement : un
+ * chiffrement de bout en bout dont l'échange de clés serait arbitré par la partie même
+ * qu'il prétend neutraliser.
+ *
+ * Retourne aussi l'horodatage, que l'appelant DOIT transmettre au serveur : sans lui, le
+ * vérificateur ne peut pas reconstruire les octets signés.
+ */
+export function buildKeyAttestation(params) {
+    const keyFingerprint = fingerprintPem(params.encryptionPublicKeyPem);
+    const payload = attestationPayload({
+        enrollment_id: params.enrollmentId,
+        project_id: params.projectId,
+        agent_id: params.agentId,
+        key_type: 'encryption',
+        key_purpose: 'envelope',
+        key_fingerprint: keyFingerprint,
+        key_epoch: params.keyEpoch ?? 1,
+        created_at: params.createdAt,
+    });
+    return {
+        payload,
+        signature: signEd25519(params.identityPrivateKeyPem, new TextEncoder().encode(payload)),
+        created_at: params.createdAt,
+        key_fingerprint: keyFingerprint,
+    };
+}
+//# sourceMappingURL=federation-attestation.js.map