brainclaw 1.21.0 → 1.23.0

package/dist/core/federation-inbound.js

@@ -0,0 +1,187 @@
+/**
+ * Vérification à la réception — fédération v2 (pln#651 étape 6, RFC §6).
+ *
+ * ── LE TROU QUE CE MODULE FERME ───────────────────────────────────────────────
+ * Avant lui, `pullSignalsFromCloud` faisait un simple `as { messages: … }` sans AUCUNE
+ * vérification, puis `materializeFederationSignal` écrivait dans la mémoire locale via
+ * saveCandidate et saveRuntimeNote. La signature Ed25519 existante était TRANSPORT
+ * uniquement, edge→cloud, dans des en-têtes : elle n'était pas persistée dans l'enveloppe
+ * et ne disait rien de l'origine du contenu.
+ *
+ * Conséquence : un cloud malveillant ne lisait pas la roadmap — elle est chiffrée — mais
+ * pouvait INJECTER des candidates et des runtime_notes dans la mémoire de chaque agent
+ * enrôlé. Soit un canal d'injection de prompt vers toute la flotte. Trois critiques sur
+ * quatre l'ont classé bloquant, par trois angles distincts.
+ *
+ * Chiffrer les LECTURES en laissant les ÉCRITURES forgeables par l'opérateur qu'on
+ * prétend neutraliser est le défaut structurel fermé ici.
+ *
+ * ── CE QUE LE CLOUD PEUT ENCORE FAIRE, ET QU'IL FAUT DIRE ─────────────────────
+ * Il peut RETARDER ou OMETTRE une enveloppe. Aucune cryptographie ne l'en empêche : un
+ * relais qui ne relaie pas est indétectable de l'intérieur. Ce qu'il ne peut plus faire,
+ * c'est injecter, rejouer une ancienne révision comme courante, ou réordonner des
+ * métadonnées sans être vu.
+ */
+import crypto from 'node:crypto';
+import { canonicalJson } from './federation-canonical.js';
+import { open as hpkeOpen } from './federation-hpke.js';
+import { FederationEnvelopeSchema, originSigningInput, } from './federation-projection.js';
+import { acceptsRevision, recordRevision } from './federation-state.js';
+function reject(reason, detail) {
+    return { ok: false, reason, detail };
+}
+/**
+ * Vérifie la signature d'origine sur les octets canoniques complets.
+ *
+ * Toute exception — PEM illisible, signature mal encodée, mauvaise longueur — rend
+ * `false` sans distinction. Laisser remonter l'erreur, ou différencier les causes,
+ * donnerait un oracle sur la RAISON du refus ; du point de vue de l'appelant il n'y a
+ * qu'un seul fait utile : ces octets ne sont pas signés par cette clé.
+ */
+function verifyOriginSignature(env, signerPem) {
+    try {
+        return crypto.verify(null, originSigningInput(env.meta, env.sealed, env.key_epoch), crypto.createPublicKey(signerPem), Buffer.from(env.origin_sig.value, 'base64url'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Vérifie une enveloppe entrante. AUCUNE écriture locale n'a lieu ici — la fonction est
+ * pure vis-à-vis du disque et rend un verdict.
+ *
+ * L'ORDRE DES CONTRÔLES EST UN CONTRAT (RFC §6) : parse strict → résolution du signataire
+ * → signature → AAD → révocation → déchiffrement → cohérence du clair → anti-rejeu →
+ * dédoublonnage. Déchiffrer AVANT d'avoir vérifié la signature exposerait le déchiffreur
+ * à un ciphertext choisi par l'attaquant ; vérifier l'anti-rejeu avant la signature
+ * laisserait un cloud faire avancer la barrière avec des révisions forgées, condamnant
+ * les révisions légitimes qui suivent.
+ */
+export function verifyInbound(params) {
+    // (1) Parse STRICT. Une clé inconnue est refusée, pas retirée en silence : c'est le
+    // pendant entrant du filet 2 du projecteur.
+    const parsed = FederationEnvelopeSchema.safeParse(params.raw);
+    if (!parsed.success) {
+        return reject('schema_invalid', parsed.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; '));
+    }
+    const env = parsed.data;
+    // (2) Résoudre le signataire DANS LE ROSTER ATTESTÉ.
+    const signerPem = params.roster.keys.get(env.origin_sig.key_id);
+    if (!signerPem) {
+        return reject('unknown_signer', `key_id '${env.origin_sig.key_id}' absent du roster attesté.`);
+    }
+    // Révoqué et inconnu sont distingués : un opérateur doit pouvoir voir qu'un membre
+    // révoqué continue d'émettre, ce qu'un « inconnu » générique masquerait.
+    if (params.roster.revoked?.has(env.origin_sig.key_id)) {
+        return reject('revoked_signer', `key_id '${env.origin_sig.key_id}' révoqué.`);
+    }
+    // (3) Signature sur les octets canoniques COMPLETS : meta, sealed (alg, enc, nonce,
+    // ciphertext) et key_epoch. Couvrir meta est ce qui rend le réordonnancement de
+    // priorité, de dépendances ou de statut détectable — le Cloud peut lire ces champs,
+    // il ne peut pas les changer.
+    if (!verifyOriginSignature(env, signerPem)) {
+        return reject('bad_signature', "la signature d'origine ne couvre pas ces octets.");
+    }
+    // (4) L'AAD doit DÉCRIRE l'objet annoncé. Sans ce contrôle, une enveloppe légitime pour
+    // l'objet A, correctement signée, pourrait être présentée comme concernant l'objet B :
+    // la signature resterait valide puisqu'elle couvre meta, mais meta lui-même mentirait
+    // sur sa cohérence interne.
+    const aad = env.meta.aad;
+    if (aad.object_id !== env.meta.id_opaque
+        || aad.base_rev !== env.meta.base_rev
+        || aad.object_type !== env.meta.kind
+        || aad.cloud_project_id !== params.state.cloud_project_id) {
+        return reject('aad_mismatch', "l'AAD ne décrit pas l'objet annoncé par meta.");
+    }
+    // (5) Déchiffrement. Échoue FERMÉ : `hpkeOpen` ne distingue pas les causes, pour ne pas
+    // offrir d'oracle sur la raison de l'échec.
+    if (!params.epochPrivateKey) {
+        return reject('undecryptable', `aucune clé détenue pour l'epoch ${env.key_epoch}.`);
+    }
+    const plaintext = hpkeOpen({
+        recipientPrivateKey: params.epochPrivateKey,
+        sealed: env.sealed,
+        aadCanonicalBytes: new TextEncoder().encode(canonicalJson(aad)),
+    });
+    if (!plaintext) {
+        return reject('undecryptable', 'AEAD refusé (clé, AAD ou tag).');
+    }
+    let content;
+    try {
+        content = JSON.parse(new TextDecoder().decode(plaintext));
+    }
+    catch {
+        return reject('payload_type_mismatch', 'le clair déchiffré n\'est pas du JSON.');
+    }
+    if (content === null || typeof content !== 'object') {
+        return reject('payload_type_mismatch', 'le clair déchiffré n\'est pas un objet.');
+    }
+    // (6) ANTI-REJEU. L'AEAD détecte l'ALTÉRATION, pas le REJEU d'un ciphertext valide et
+    // ancien. Sans high-water mark, un cloud peut resservir un état antérieur comme s'il
+    // était courant, et rien dans la cryptographie ne s'y oppose.
+    //
+    // Le dédoublonnage est vérifié AVANT le rejeu : une enveloppe DÉJÀ matérialisée a
+    // légitimement une révision égale au high-water mark. La confondre avec un rejeu
+    // rendrait tout retour d'un retry indistinguable d'une attaque.
+    const idempotencyKey = env.meta.transport.idempotency_key;
+    if (params.seenIdempotencyKeys?.has(idempotencyKey)) {
+        return reject('duplicate', `opération déjà matérialisée (${idempotencyKey}).`);
+    }
+    if (!acceptsRevision(params.state, env.meta.id_opaque, env.meta.base_rev)) {
+        const seen = params.state.sync.high_water[env.meta.id_opaque];
+        return reject('replay_or_rollback', `révision ${env.meta.base_rev} refusée pour ${env.meta.id_opaque} : high-water mark à ${seen}.`);
+    }
+    return {
+        ok: true,
+        envelope: env,
+        content,
+        kind: env.meta.kind,
+        idempotencyKey,
+        nextState: recordRevision(params.state, env.meta.id_opaque, env.meta.base_rev),
+    };
+}
+/**
+ * Vérifie un lot d'enveloppes et rend le verdict de chacune.
+ *
+ * L'ÉTAT AVANCE AU FIL DU LOT, et l'ordre compte : deux révisions du même objet dans un
+ * même lot doivent être appliquées dans l'ordre croissant, sinon la seconde est refusée
+ * comme rollback — ce qui est le comportement voulu. Un lot est traité comme une suite
+ * d'opérations, jamais comme un ensemble à réordonner selon ce que le Cloud propose.
+ *
+ * Le dédoublonnage accumule les clés vues DANS le lot en plus de celles déjà connues :
+ * un cloud qui livrerait deux fois la même opération dans un seul lot serait sinon
+ * accepté deux fois.
+ */
+export function verifyInboundBatch(params) {
+    const seen = new Set(params.seenIdempotencyKeys ?? []);
+    let state = params.state;
+    const results = [];
+    let accepted = 0;
+    for (const raw of params.envelopes) {
+        // L'epoch est lu sur l'enveloppe AVANT vérification, uniquement pour choisir une clé.
+        // Ce n'est pas une décision de confiance : une valeur mensongère mène simplement à
+        // une clé qui n'ouvrira pas, donc à un refus.
+        const epoch = typeof raw?.key_epoch === 'number'
+            ? raw.key_epoch
+            : undefined;
+        const result = verifyInbound({
+            raw,
+            roster: params.roster,
+            state,
+            epochPrivateKey: epoch === undefined ? undefined : params.epochKeys.get(epoch),
+            seenIdempotencyKeys: seen,
+        });
+        results.push(result);
+        if (result.ok) {
+            // L'état n'avance QUE sur acceptation. Une enveloppe refusée ne doit laisser aucune
+            // trace : ni barrière avancée, ni clé d'idempotence enregistrée. Sinon un cloud
+            // hostile empoisonnerait l'état avec des enveloppes invalides et condamnerait les
+            // révisions légitimes qui suivent.
+            state = result.nextState;
+            seen.add(result.idempotencyKey);
+            accepted++;
+        }
+    }
+    return { results, nextState: state, accepted, rejected: results.length - accepted };
+}
+//# sourceMappingURL=federation-inbound.js.map

package/dist/core/federation-keyring.js

@@ -0,0 +1,241 @@
+/**
+ * Fédération v2 — identité d'APPAREIL et trousseau multi-epoch (pln#651 étape 3).
+ *
+ * Création propre, AUCUNE migration (dec#156) : ce module ne lit ni `cloud_sync` ni
+ * `BRAINCLAW_CLOUD_*` pour reconstruire un état. Le chemin v1 a été démoli en étape 2.
+ *
+ * ── POURQUOI DEUX PAIRES DE CLÉS ET NON UNE ────────────────────────────────────
+ * L'appareil porte DEUX clés distinctes, et aucune ne se dérive de l'autre :
+ *
+ *   Ed25519 (~/.brainclaw/keys/<agentId>.ed25519.pem, agent-registry.ts)
+ *     → QUI PARLE. Signature d'origine des enveloppes, preuve de possession
+ *       pendant l'appairage. C'est l'identité que le Cloud a déjà enregistrée.
+ *
+ *   X25519 (~/.brainclaw/keys/<deviceId>.x25519.pem, ce module)
+ *     → QUI PEUT LIRE. Destinataire des enveloppements HPKE qui remettent les
+ *       clés privées d'epoch.
+ *
+ * Les dériver l'une de l'autre est tentant (une seule clé à sauvegarder) et faux :
+ * cela lierait la capacité de LECTURE à la capacité de SIGNATURE, alors que le RFC
+ * §5.1 en fait une propriété d'architecture — « écrire sans lire ». Un émetteur qui
+ * ne doit pas lire reçoit la clé publique de projet et son accès de signature, rien
+ * d'autre. Avec des clés dérivées, révoquer la lecture révoquerait l'écriture, et
+ * la compromission de l'une livrerait l'autre.
+ *
+ * ── PLAFOND DE SÉCURITÉ, ÉCRIT ICI PARCE QUE C'EST ICI QU'ON LIT LA CLÉ ────────
+ * `~/.brainclaw/keys/` est un répertoire du système de fichiers, lisible par TOUT
+ * processus tournant sous le même UID. Sur Windows le mode 0600 de `fs.chmod` est
+ * largement ignoré. Donc : la sécurité du chiffrement de bout en bout côté Cloud
+ * NE DÉPASSE PAS celle du disque local. Un malware ayant l'UID de l'utilisateur lit
+ * les clés d'epoch et déchiffre tout ce que l'appareil pouvait déchiffrer.
+ *
+ * Ce n'est pas un défaut à corriger dans ce step : TPM, enclave sécurisée et HSM
+ * sont explicitement une v2 ultérieure (RFC §5.1). C'est un plafond à ÉNONCER, pour
+ * qu'on ne vende pas au-delà de ce que la construction tient.
+ */
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { MEMORY_DIR } from './io.js';
+import { nowISO } from './ids.js';
+import { logger } from './logger.js';
+/** Empreinte canonique d'une clé publique PEM — même règle que Ed25519 (agent-registry.ts). */
+export function fingerprintKeyPem(publicKeyPem) {
+    return crypto.createHash('sha256').update(publicKeyPem.replace(/\r/g, '').trim()).digest('hex');
+}
+// ── Emplacements ──────────────────────────────────────────────────────────────
+/** Racine neutre des secrets : ~/.brainclaw/ — JAMAIS le store de workspace. */
+function keysRoot(home = os.homedir()) {
+    return path.join(home, MEMORY_DIR, 'keys');
+}
+/**
+ * Clé privée X25519 de l'appareil.
+ *
+ * Voisine de la clé Ed25519 par CHOIX : un seul répertoire à protéger, à sauvegarder
+ * et à effacer. Le suffixe distingue les deux algorithmes de façon lisible sans avoir
+ * à ouvrir le fichier.
+ */
+export function deviceKeyPath(deviceId, home = os.homedir()) {
+    return path.join(keysRoot(home), `${deviceId}.x25519.pem`);
+}
+/**
+ * Clés privées d'epoch, cloisonnées PAR PROJET CLOUD.
+ *
+ * Le cloisonnement n'est pas cosmétique : `disconnect` d'un projet doit pouvoir
+ * effacer ses clés sans toucher à celles d'un autre projet auquel la même machine
+ * est appairée. Un trousseau à plat rendrait cette suppression sélective fragile.
+ */
+export function epochKeyPath(cloudProjectId, epoch, home = os.homedir()) {
+    return path.join(keysRoot(home), 'epochs', cloudProjectId, `epoch-${epoch}.x25519.pem`);
+}
+function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+/**
+ * Écrit un secret sur disque en RESTREIGNANT les permissions AVANT d'écrire les
+ * octets, pas après.
+ *
+ * `writeFileSync(p, data)` puis `chmodSync(p, 0o600)` laisse une fenêtre où le
+ * fichier existe en 0644 avec la clé dedans. Le mode passé à l'ouverture ferme
+ * cette fenêtre. Sur Windows le mode est largement ignoré — d'où le plafond
+ * documenté en tête de module ; ce n'est pas une raison de l'omettre sur POSIX,
+ * où il est effectif.
+ */
+function writeSecretFile(filepath, contents) {
+    ensureDir(path.dirname(filepath));
+    fs.writeFileSync(filepath, contents, { encoding: 'utf-8', mode: 0o600 });
+}
+/**
+ * Retourne la clé X25519 de l'appareil, en la créant au premier appel.
+ *
+ * NE FAIT JAMAIS TOURNER une clé existante — même contrat que `ensureAgentSigningKey`
+ * pour Ed25519, et pour la même raison en plus grave : une rotation silencieuse
+ * casserait l'attestation déjà approuvée par un humain côté Cloud, et rendrait
+ * ILLISIBLES toutes les enveloppes d'epoch déjà remises à l'ancienne clé. Une clé de
+ * signature perdue empêche d'écrire ; une clé de déchiffrement perdue perd des données.
+ */
+export function ensureDeviceKey(deviceId, home = os.homedir()) {
+    const filepath = deviceKeyPath(deviceId, home);
+    if (fs.existsSync(filepath)) {
+        const privateKey = crypto.createPrivateKey(fs.readFileSync(filepath, 'utf-8'));
+        const publicKeyPem = crypto
+            // @types/node 26 a retiré la surcharge KeyObject de createPublicKey (régression :
+            // Node accepte une clé privée pour en dériver la publique, comme documenté).
+            // Même contournement que agent-registry.ts ; comportement d'exécution inchangé.
+            .createPublicKey(privateKey)
+            .export({ type: 'spki', format: 'pem' })
+            .toString();
+        return {
+            device_id: deviceId,
+            public_key_pem: publicKeyPem,
+            fingerprint: fingerprintKeyPem(publicKeyPem),
+            created_at: fs.statSync(filepath).birthtime.toISOString(),
+        };
+    }
+    const generated = crypto.generateKeyPairSync('x25519');
+    const privateKeyPem = generated.privateKey.export({ type: 'pkcs8', format: 'pem' }).toString();
+    const publicKeyPem = generated.publicKey.export({ type: 'spki', format: 'pem' }).toString();
+    writeSecretFile(filepath, privateKeyPem);
+    return {
+        device_id: deviceId,
+        public_key_pem: publicKeyPem,
+        fingerprint: fingerprintKeyPem(publicKeyPem),
+        created_at: nowISO(),
+    };
+}
+/**
+ * Charge la clé privée X25519 de l'appareil, ou `undefined` si absente.
+ *
+ * Ne CRÉE rien : un appelant qui a besoin de déchiffrer et ne trouve pas la clé doit
+ * traiter cela comme un échec explicite, pas voir une clé fraîche se matérialiser et
+ * échouer plus tard, plus loin, sur un déchiffrement incompréhensible.
+ */
+export function loadDevicePrivateKey(deviceId, home = os.homedir()) {
+    const filepath = deviceKeyPath(deviceId, home);
+    if (!fs.existsSync(filepath))
+        return undefined;
+    return crypto.createPrivateKey(fs.readFileSync(filepath, 'utf-8'));
+}
+/**
+ * Enregistre la clé privée d'un epoch, remise par une enveloppe HPKE après approbation.
+ *
+ * REFUSE D'ÉCRASER un epoch déjà détenu. Deux clés différentes pour un même numéro
+ * d'epoch signifie que quelque chose s'est mal passé en amont — le Cloud a resservi un
+ * autre roster, ou deux appairages se marchent dessus. Écraser rendrait silencieusement
+ * illisible tout ce qui a été scellé sous la première ; l'erreur est le bon comportement.
+ * Ré-enregistrer la MÊME clé est en revanche idempotent : une reprise d'appairage
+ * interrompu ne doit pas échouer (le step 4 exige une reprise sûre).
+ */
+export function storeEpochPrivateKey(cloudProjectId, epoch, privateKeyPem, home = os.homedir()) {
+    const filepath = epochKeyPath(cloudProjectId, epoch, home);
+    if (fs.existsSync(filepath)) {
+        const existing = fs.readFileSync(filepath, 'utf-8').replace(/\r/g, '').trim();
+        if (existing === privateKeyPem.replace(/\r/g, '').trim())
+            return;
+        throw new Error(`Refus d'écraser la clé de l'epoch ${epoch} du projet ${cloudProjectId} : ` +
+            `une clé DIFFÉRENTE est déjà détenue. Écraser rendrait illisible tout ce qui a été ` +
+            `scellé sous la clé actuelle. Vérifier le roster côté cloud avant de forcer.`);
+    }
+    // Valider AVANT d'écrire : un PEM corrompu stocké se découvrirait au premier
+    // déchiffrement, longtemps après, sans lien évident avec l'appairage qui l'a produit.
+    const key = crypto.createPrivateKey(privateKeyPem);
+    if (key.asymmetricKeyType !== 'x25519') {
+        throw new Error(`Clé d'epoch invalide : attendu x25519, reçu ${key.asymmetricKeyType ?? 'inconnu'}`);
+    }
+    writeSecretFile(filepath, privateKeyPem);
+}
+/** Charge la clé privée d'un epoch, ou `undefined` si cet epoch n'est pas détenu. */
+export function loadEpochPrivateKey(cloudProjectId, epoch, home = os.homedir()) {
+    const filepath = epochKeyPath(cloudProjectId, epoch, home);
+    if (!fs.existsSync(filepath))
+        return undefined;
+    try {
+        return crypto.createPrivateKey(fs.readFileSync(filepath, 'utf-8'));
+    }
+    catch (err) {
+        // Une clé illisible n'est PAS équivalente à une clé absente : la première est une
+        // corruption à signaler, la seconde un état normal. On journalise et on renvoie
+        // undefined pour que l'appelant refuse le déchiffrement — jamais un fallback muet.
+        logger.warn(`Clé d'epoch ${epoch} illisible pour ${cloudProjectId}: ${err instanceof Error ? err.message : String(err)}`);
+        return undefined;
+    }
+}
+/**
+ * Énumère les epochs dont la clé privée est détenue localement — le trousseau réel,
+ * lu SUR DISQUE et non déduit de l'état de connexion.
+ *
+ * La distinction compte : l'état de connexion dit ce que l'appareil CROIT détenir,
+ * le disque dit ce qu'il détient VRAIMENT. `federation-state.ts` réconcilie les deux
+ * plutôt que de faire confiance au JSON, parce qu'une restauration partielle de
+ * sauvegarde produit exactement ce désaccord.
+ */
+export function heldEpochs(cloudProjectId, home = os.homedir()) {
+    const dir = path.dirname(epochKeyPath(cloudProjectId, 0, home));
+    if (!fs.existsSync(dir))
+        return [];
+    const epochs = [];
+    for (const entry of fs.readdirSync(dir)) {
+        const match = /^epoch-(\d+)\.x25519\.pem$/.exec(entry);
+        if (match)
+            epochs.push(Number(match[1]));
+    }
+    return epochs.sort((a, b) => a - b);
+}
+/**
+ * Efface les clés d'epoch d'un projet — appelé par `cloud disconnect`.
+ *
+ * CE QUE ÇA NE FAIT PAS, et que la commande appelante doit dire à l'humain : cela
+ * n'efface pas les blobs déjà tirés et déchiffrés localement, ni ce qu'un autre
+ * appareil détient. `disconnect` retire une autorisation locale ; il ne réécrit pas
+ * le passé (RFC §5.2). Retourne le nombre de clés supprimées.
+ */
+export function forgetProjectEpochs(cloudProjectId, home = os.homedir()) {
+    const dir = path.dirname(epochKeyPath(cloudProjectId, 0, home));
+    if (!fs.existsSync(dir))
+        return 0;
+    let removed = 0;
+    for (const entry of fs.readdirSync(dir)) {
+        if (!/^epoch-\d+\.x25519\.pem$/.test(entry))
+            continue;
+        fs.rmSync(path.join(dir, entry), { force: true });
+        removed++;
+    }
+    try {
+        fs.rmdirSync(dir);
+    }
+    catch { /* non vide ou déjà parti : sans conséquence */ }
+    return removed;
+}
+/** Clé publique d'un epoch détenu, dérivée de la privée — utile pour afficher son empreinte. */
+export function epochPublicKey(cloudProjectId, epoch, home = os.homedir()) {
+    const priv = loadEpochPrivateKey(cloudProjectId, epoch, home);
+    if (!priv)
+        return undefined;
+    const pem = crypto
+        .createPublicKey(priv)
+        .export({ type: 'spki', format: 'pem' })
+        .toString();
+    return { public_key_pem: pem, fingerprint: fingerprintKeyPem(pem) };
+}
+//# sourceMappingURL=federation-keyring.js.map

package/dist/core/federation-message.js

@@ -13,17 +13,17 @@ export const FederationMessageSchema = z.object({
         agent_name: z.string(),
         agent_id: z.string().optional(),
         host_id: z.string().optional(),
-    }),
+    }).strict(),
     to: z.object({
         project_name: z.string(),
         project_path: z.string(),
         agent_name: z.string().optional(),
-    }),
-    type: z.enum(['signal', 'handoff', 'candidate', 'runtime_note', 'board_snapshot']),
-    payload: z.unknown(),
+    }).strict(),
+    type: z.enum(['handoff', 'candidate', 'runtime_note']),
+    payload: z.record(z.string(), z.unknown()),
     created_at: z.string(),
     causal_parent: z.string().optional(),
-});
+}).strict();
 function computeIdempotencyKey(msg) {
     const data = JSON.stringify({ from: msg.from, to: msg.to, type: msg.type, payload: msg.payload });
     return crypto.createHash('sha256').update(data).digest('hex').slice(0, 16);

package/dist/core/federation-outbox-v2.js

@@ -0,0 +1,125 @@
+/**
+ * Fédération v2 — outbox locale (pln#651 étape 3).
+ *
+ * Création propre : l'outbox v1 (`federation-outbox.ts`) a été SUPPRIMÉE en étape 2 avec
+ * ses 112 enveloppes en attente, dont 50 portaient un `worktree_path` absolu et 48 le nom
+ * d'hôte de la machine (dec#156-d). Rien n'est repris d'elle — ni format, ni contenu.
+ *
+ * ── CE QUE CETTE OUTBOX SAIT, ET CE QU'ELLE NE SAIT PAS ───────────────────────
+ * Elle stocke des enveloppes DÉJÀ SCELLÉES et suit leur état. Elle ne construit pas
+ * l'enveloppe, ne chiffre pas, ne classe pas les champs : c'est l'étape 5 (le projecteur
+ * et ses trois filets). La séparation est délibérée — une file d'attente qui saurait
+ * aussi fabriquer son contenu serait un second chemin de sérialisation, donc un second
+ * endroit où un champ non classé peut fuir.
+ *
+ * Conséquence testable : ce module n'accepte QUE la partie `sealed` opaque et des
+ * métadonnées de transport. Il n'a aucun accès au clair, donc il ne peut pas le divulguer.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { memoryDir, writeFileAtomic } from './io.js';
+import { nowISO } from './ids.js';
+import { logger } from './logger.js';
+/** Les trois répertoires SONT les trois états — l'état est le chemin, pas un champ. */
+const STATE_DIRS = {
+    pending: 'outbox',
+    synced: 'sent',
+    conflict: 'conflict',
+};
+export const OUTBOX_ENTRY_SCHEMA = 'brainclaw.federation-outbox-entry/v2';
+function stateDir(state, cwd) {
+    return path.join(memoryDir(cwd), 'coordination', 'federation', STATE_DIRS[state]);
+}
+function entryPath(state, idempotencyKey, cwd) {
+    return path.join(stateDir(state, cwd), `${idempotencyKey}.json`);
+}
+/**
+ * Met une enveloppe scellée en file d'attente.
+ *
+ * IDEMPOTENT PAR CONSTRUCTION : la clé d'idempotence est le NOM DU FICHIER, donc un
+ * double enqueue de la même opération ne peut pas produire deux entrées. C'est ce que
+ * `materializeFederationSignal` ne faisait pas — il frappait un nouvel id et un nouveau
+ * created_at à chaque passage, rendant le dédoublonnage absent par construction (étape 6).
+ *
+ * Une entrée déjà `synced` n'est pas remise en attente : la retransmission d'une opération
+ * confirmée est exactement le rejeu contre lequel l'étape 6 protège à la réception ; il
+ * n'y a pas de raison de l'émettre depuis ici.
+ */
+export function enqueue(entry, cwd = process.cwd()) {
+    for (const state of ['synced', 'pending', 'conflict']) {
+        if (fs.existsSync(entryPath(state, entry.idempotency_key, cwd)))
+            return false;
+    }
+    const now = nowISO();
+    const full = { schema: OUTBOX_ENTRY_SCHEMA, ...entry, attempts: 0, created_at: now, updated_at: now };
+    const filepath = entryPath('pending', entry.idempotency_key, cwd);
+    fs.mkdirSync(path.dirname(filepath), { recursive: true });
+    writeFileAtomic(filepath, `${JSON.stringify(full, null, 2)}\n`);
+    return true;
+}
+/**
+ * Déplace une entrée d'un état vers un autre.
+ *
+ * Le déplacement est un `rename` : une entrée ne peut pas exister dans deux états à la
+ * fois, même si le processus meurt au milieu. Une copie-puis-suppression laisserait une
+ * fenêtre où l'opération est comptée deux fois — et les compteurs de `status` mentiraient
+ * précisément pendant l'incident où on les consulte.
+ */
+export function transition(idempotencyKey, from, to, cwd = process.cwd(), mutate) {
+    const src = entryPath(from, idempotencyKey, cwd);
+    if (!fs.existsSync(src))
+        return false;
+    const dest = entryPath(to, idempotencyKey, cwd);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    if (mutate) {
+        try {
+            const entry = JSON.parse(fs.readFileSync(src, 'utf-8'));
+            const next = mutate({ ...entry, updated_at: nowISO() });
+            writeFileAtomic(dest, `${JSON.stringify(next, null, 2)}\n`);
+            fs.rmSync(src, { force: true });
+            return true;
+        }
+        catch (err) {
+            logger.warn(`Entrée d'outbox illisible (${idempotencyKey}) : ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+    }
+    fs.renameSync(src, dest);
+    return true;
+}
+/** Entrées d'un état donné, triées par date de création. */
+export function list(state, cwd = process.cwd()) {
+    const dir = stateDir(state, cwd);
+    if (!fs.existsSync(dir))
+        return [];
+    const entries = [];
+    for (const name of fs.readdirSync(dir)) {
+        if (!name.endsWith('.json'))
+            continue;
+        try {
+            entries.push(JSON.parse(fs.readFileSync(path.join(dir, name), 'utf-8')));
+        }
+        catch {
+            // Une entrée corrompue est ignorée à la lecture mais reste sur disque : la
+            // supprimer ici effacerait la seule trace d'une opération peut-être jamais émise.
+            logger.warn(`Entrée d'outbox ignorée (illisible) : ${name}`);
+        }
+    }
+    return entries.sort((a, b) => a.created_at.localeCompare(b.created_at));
+}
+/**
+ * Compte les trois états EN LES LISANT SUR DISQUE.
+ *
+ * Les compteurs de `connection.json` sont un cache d'affichage ; ceci est la vérité. Le
+ * critère de sortie de l'étape 3 dit « observables par une commande » — observer un
+ * compteur qu'on a soi-même incrémenté n'observe rien, c'est se relire. En cas d'écart,
+ * c'est ce comptage qui gagne.
+ */
+export function counters(cwd = process.cwd()) {
+    return {
+        pending: list('pending', cwd).length,
+        synced: list('synced', cwd).length,
+        conflict: list('conflict', cwd).length,
+    };
+}
+//# sourceMappingURL=federation-outbox-v2.js.map