tabtree-mcp 1.2.1 → 1.5.0

package/tabtree-mcp.mjs

@@ -7,21 +7,33 @@
 // sans passer par l'interface — génération depuis une conversation,
 // un document, un plan…
 //
-// Où : le serveur travaille sur le DOSSIER DE SAUVEGARDE AUTO de TabTree
-// (celui choisi via 🛟 dans « Mes cartes ») : 1 fichier .ygmind par carte
-// + bibliotheque.json (manifeste, propriété de l'app — jamais modifié ici).
-// Le MCP ne crée que de NOUVEAUX fichiers ; l'app les avale par le menu 🛟
-// (« Bring maps back from this folder… »), avec dédoublonnage et sans écrasement.
+// Où (1.5.0, 2026-10-20) : le COMPTE TabTree. TabTree est 100 % en ligne depuis le 2026-10-20
+// (Zemind seule source, la licence Classic arrêtée) : la source normale est la clé personnelle
+// `TABTREE_API_KEY` et l'edge function `mcp` (supabase/functions/mcp), qui voit la bibliothèque
+// du compte ET les espaces d'équipe dont il est membre (migration 0033).
 //
-// Config : TABTREE_DIR = chemin du dossier. YGMIND_DIR (ancien nom) reste accepté,
-// pour qu'un .mcp.json écrit avant le renommage continue de marcher sans retouche.
+// Le DOSSIER 🛟 (TABTREE_DIR, ancien nom YGMIND_DIR) reste lu par compatibilité : les acheteurs
+// Classic ont des connecteurs installés qui le pointent, et la fin de Classic n'est pas encore
+// annoncée côté ventes. Il n'est plus documenté que comme ancien mode — ne pas y ajouter de
+// fonction : tout ce qui est nouveau (espaces, application sans clic) n'existe qu'en compte.
+//
+// Ce fichier vit dans le dépôt Zemind depuis la 1.5.0 (mcp/) — il était dans le moteur figé, et
+// son test de dérive comparait au moteur, plus à ce qui est en ligne. Il compare app/index.html.
 // Protocole : JSON-RPC 2.0, un message JSON par ligne sur stdin/stdout.
 // ============================================================================
 
-import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, mkdirSync } from "node:fs";
-import { join, basename } from "node:path";
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { join, basename, resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+import { inflateSync, deflateSync } from "node:zlib";
+import { tmpdir, platform } from "node:os";
 
-const DIR = process.env.TABTREE_DIR || process.env.YGMIND_DIR || "";
+// ⚠️ LE GABARIT NON RÉSOLU vaut « vide », pour le dossier comme pour la clé (2026-10-20). Claude
+// Desktop passe `${user_config.backup_folder}` TEL QUEL quand le champ (ancien, Classic) est vide :
+// pris pour un chemin, il produisait « The TABTREE_DIR folder does not exist: ${user_config…} » —
+// un message sur un dossier que l'utilisateur n'a jamais choisi, qui cachait la vraie cause (la clé).
+const DIR_RAW = process.env.TABTREE_DIR || process.env.YGMIND_DIR || "";
+const DIR = /^\$\{.*\}$/.test(String(DIR_RAW).trim()) ? "" : DIR_RAW;
 // ---------------------------------------------------------------------------
 // DEUX SOURCES, UN CONNECTEUR (2026-09-08). Le dossier 🛟 sert TabTree Classic (le fichier
 // local) ; le CLOUD sert l'abonné TabTree SaaS. La source est choisie par la présence d'une
@@ -36,7 +48,11 @@ let API_KEY = String(process.env.TABTREE_API_KEY || "").trim();
 // Trousseau et liée à l'installation précédente). `CLOUD = !!API_KEY` prenait ce littéral pour
 // une clé, l'envoyait, et le serveur répondait « Unknown or revoked connector key » : un
 // message FAUX, qui envoie chercher une clé révoquée là où il n'y a simplement rien de saisi.
-if(/^\$\{.*\}$/.test(API_KEY)) API_KEY = "";
+// Mesuré de nouveau le 2026-10-20 (mise à jour 1.3.0 → 1.5.0 par la page /connector) : la clé
+// était bien enregistrée — chiffrée, liée à l'installation précédente — et c'est le gabarit qui
+// est arrivé. On s'en souvient pour DIRE la cause au lieu de « aucune source ».
+const KEY_UNSENT = /^\$\{.*\}$/.test(API_KEY);
+if(KEY_UNSENT) API_KEY = "";
 const API_URL = String(process.env.TABTREE_API_URL || "https://aynmiptyvisxoslzkzxn.supabase.co/functions/v1/mcp").trim();
 const CLOUD = !!API_KEY;
 // La FORME d'une clé se vérifie ici, avant tout aller-retour : l'app en fabrique une en
@@ -54,7 +70,9 @@ async function cloudCall(action, body){
   try{
     r = await fetch(API_URL, { method:"POST",
       headers:{ "content-type":"application/json", "x-tabtree-key": API_KEY },
-      body: JSON.stringify(Object.assign({ action }, body || {})) });
+      // `v: 2` : le contrat 1.5.0 (espaces d'équipe, propriétaire de chaque carte, pagination).
+      // Une edge function plus ancienne l'ignore ; une plus récente sert les 1.2–1.4 sans `v` à l'identique.
+      body: JSON.stringify(Object.assign({ action, v: 2 }, body || {})) });
   }catch(e){ throw new Error("Could not reach the TabTree cloud (" + (e && e.message || e) + ")."); }
   let j = null; try{ j = await r.json(); }catch(e){}
   if(!r.ok || !j || j.ok === false) throw new Error((j && j.error) || ("The TabTree cloud answered HTTP " + r.status + "."));
@@ -72,6 +90,7 @@ const PROP_DIR = "Propositions";
 // ---------------------------------------------------------------------------
 function dirOk(){
   if(CLOUD) return;   // la source est le compte, pas un dossier
+  if(!DIR && KEY_UNSENT) throw new Error("Claude Desktop did not pass your TabTree connector key to the connector. This happens after the extension is updated or reinstalled: the key saved in its settings belongs to the previous install. Open Claude Desktop → Settings → Extensions → TabTree, paste your key again (create one in TabTree → Settings → Account → Claude connector if you need to), then quit Claude Desktop completely and reopen it.");
   if(!DIR) throw new Error("The connector has no source. For TabTree (subscription), set TABTREE_API_KEY to the connector key from ⚙️ Settings → Account → Claude connector. For TabTree Classic (the local file), set TABTREE_DIR to your 🛟 backup folder. (The older name YGMIND_DIR still works.)");
   if(!existsSync(DIR)) throw new Error("The TABTREE_DIR folder does not exist: " + DIR);
 }
@@ -157,9 +176,17 @@ const ART_IDS_MCP = [
   "house", "pin", "plane", "coffee", "plant", "sun",
   "camera", "music", "lock", "key", "health", "gift",
   "manager", "client", "expert", "assistant", "coach", "learner",
-  "developer", "seller", "support", "speaker", "freelancer", "group"
+  "developer", "seller", "support", "speaker", "freelancer", "group",
+  "uilogin", "uifeed", "uichat", "uidash", "uichart", "uishop",
+  "uimap", "uivideo", "uislide", "uiprofile", "uiboard", "uitable",
+  "atom", "dna", "flask", "microscope", "brain", "planet",
+  "pencil", "gradcap", "calc", "palette", "ruler", "backpack"
 ];
 const ART = Object.fromEntries(ART_IDS_MCP.map(id=>[id, true]));
+// ≡ `artHas` d'app/index.html : seule une propriété PROPRE compte. `ART["toString"]` est une
+// fonction héritée, vraie au test de vérité — « a:toString » passait `okPic` ici alors que l'app
+// le refusait déjà (dérive attrapée le 2026-10-20 en comparant enfin au fichier EN LIGNE).
+const artHas = id => typeof id === "string" && Object.prototype.hasOwnProperty.call(ART, id);
   const EMO_PIC_PAT = "\\p{Extended_Pictographic}(?:\\uFE0F|\\uFE0E)?(?:\\u200D\\p{Extended_Pictographic}(?:\\uFE0F|\\uFE0E)?)*";
   const PIC_EMO_RE = (()=>{
     try{ return new RegExp("^(?:" + EMO_PIC_PAT + ")$", "u"); }
@@ -169,7 +196,7 @@ const ART = Object.fromEntries(ART_IDS_MCP.map(id=>[id, true]));
   })();
 function okPic(v){
     if(typeof v !== "string" || !v || v.length > PIC_MAX) return "";
-    if(v.startsWith("a:")) return ART[v.slice(2)] ? v : "";
+    if(v.startsWith("a:")) return artHas(v.slice(2)) ? v : "";
     if(v.startsWith("e:")){
       const ch = v.slice(2);
       return (ch && PIC_EMO_RE.test(ch)) ? "e:" + ch : "";
@@ -185,6 +212,276 @@ function tplPicAssign(n){
     })(n);
   }
 
+// ---------------------------------------------------------------------------
+// Une CAPTURE D'ÉCRAN sur un nœud (`node.img`, 2026-09-15)
+//
+// Demande de l'utilisateur : « générer une mindmap avec des screenshots tirés d'une app ».
+// Le champ existait de bout en bout — `node.img` est la COUVERTURE d'un nœud, tenue dans les
+// cinq places, peinte sur le canevas, dans l'export et sur le recto kanban. Ce qui manquait,
+// c'est la PORTE : le connecteur ne savait poser qu'une désignation (`pic`), jamais des pixels.
+//
+// Deux contraintes décident de tout ce qui suit :
+//  1. `okCover` (index.html) n'accepte qu'un `data:image/(png|jpeg|webp|gif)` de moins de
+//     COVER_MAX_BYTES caractères. Une capture d'écran Retina fait 2 à 5 Mo : embarquée telle
+//     quelle, l'app la REFUSE à l'ouverture et le nœud arrive nu — sans une erreur. Il faut donc
+//     ré-encoder ICI, avant d'écrire. La constante et la fonction sont portées MOT POUR MOT et le
+//     test les compare à l'app : si elles divergent, le connecteur écrit une image que l'app
+//     efface, et personne ne sait pourquoi.
+//  2. Le connecteur est ZÉRO dépendance et Node n'a aucun codec d'image. Trois encodeurs, dans
+//     l'ordre : `sips` (livré avec macOS), `magick`/`convert` (ImageMagick, s'il est là), et un
+//     chemin PUR JS — décodeur PNG (zlib est natif), réduction par moyenne de zone, encodeur PNG.
+//     Le chemin JS ne lit que du PNG, ce qui est le format de TOUTES les captures que Claude
+//     produit (navigateur, computer-use, simulateur). Quand rien ne tient dans le budget, on
+//     REFUSE en nommant la limite — jamais une image tronquée, jamais un nœud silencieusement nu.
+//
+// Le côté long est ré-encodé à IMG_LONG = 840 px, soit 2 × COVER_MAX_DIM : l'app affiche une
+// couverture à 420 px au plus, et 840 la garde nette sur un écran Retina. Au-delà on stockerait
+// des pixels que personne ne voit. Le budget par image (IMG_BUDGET) est bien plus bas que
+// COVER_MAX_BYTES, et c'est délibéré : vingt captures à 900 Ko feraient un document de 18 Mo, lu
+// SYNCHRONIQUEMENT depuis le miroir localStorage de l'app. À 840 px en JPEG, une capture pèse
+// 80 à 200 Ko ; en PNG (chemin JS) 150 à 400 Ko — d'où les trois paliers de repli.
+// ---------------------------------------------------------------------------
+const COVER_MAX_BYTES = 900000; // ~900 Ko de data URL : au-delà, on refuse
+function okCover(v){
+    return (typeof v === "string" && v.length <= COVER_MAX_BYTES
+      && /^data:image\/(png|jpeg|webp|gif);base64,[A-Za-z0-9+/=]+$/.test(v)) ? v : "";
+  }
+const IMG_LONG = 840;                     // côté long visé (2 × COVER_MAX_DIM de l'app)
+const IMG_STEPS = [840, 600, 420];        // paliers de repli quand le budget ne tient pas
+const IMG_BUDGET = 320000;                // data URL par image — bien sous COVER_MAX_BYTES, voir ci-dessus
+const IMG_FILE_MAX = 40 * 1024 * 1024;    // un fichier plus gros n'est pas une capture d'écran
+const IMG_JPEG_Q = 82;
+const IMG_MIMES = { png:"image/png", jpeg:"image/jpeg", webp:"image/webp", gif:"image/gif" };
+
+// Sonde les octets, jamais l'extension : un « .png » qui contient du JPEG s'ouvre partout, et
+// c'est l'octet qui décide de ce que l'app saura décoder.
+function imageInfo(buf){
+  if(!buf || buf.length < 12) return null;
+  if(buf[0] === 0x89 && buf.toString("latin1", 1, 4) === "PNG" && buf.length >= 24)
+    return { kind:"png", w: buf.readUInt32BE(16), h: buf.readUInt32BE(20) };
+  if(buf[0] === 0xFF && buf[1] === 0xD8){
+    let i = 2;
+    while(i + 9 < buf.length){
+      if(buf[i] !== 0xFF){ i++; continue; }
+      const m = buf[i + 1];
+      if(m === 0xFF){ i++; continue; }
+      if(m >= 0xC0 && m <= 0xCF && m !== 0xC4 && m !== 0xC8 && m !== 0xCC)
+        return { kind:"jpeg", h: buf.readUInt16BE(i + 5), w: buf.readUInt16BE(i + 7) };
+      if(m === 0xD8 || (m >= 0xD0 && m <= 0xD7) || m === 0x01){ i += 2; continue; }
+      i += 2 + buf.readUInt16BE(i + 2);
+    }
+    return { kind:"jpeg", w:0, h:0 };
+  }
+  if(buf.toString("latin1", 0, 4) === "GIF8")
+    return { kind:"gif", w: buf.readUInt16LE(6), h: buf.readUInt16LE(8) };
+  if(buf.toString("latin1", 0, 4) === "RIFF" && buf.toString("latin1", 8, 12) === "WEBP" && buf.length >= 30){
+    const c = buf.toString("latin1", 12, 16);
+    if(c === "VP8 ") return { kind:"webp", w: buf.readUInt16LE(26) & 0x3fff, h: buf.readUInt16LE(28) & 0x3fff };
+    if(c === "VP8L"){ const b = buf.subarray(21, 25); return { kind:"webp", w: 1 + (((b[1] & 0x3F) << 8) | b[0]), h: 1 + (((b[3] & 0xF) << 10) | (b[2] << 2) | ((b[1] & 0xC0) >> 6)) }; }
+    if(c === "VP8X") return { kind:"webp", w: 1 + buf.readUIntLE(24, 3), h: 1 + buf.readUIntLE(27, 3) };
+    return { kind:"webp", w:0, h:0 };
+  }
+  return null;
+}
+function dataUrlOf(buf, kind){ return "data:" + IMG_MIMES[kind] + ";base64," + buf.toString("base64"); }
+
+// --- Le chemin PUR JS : PNG → RGB, réduction, → PNG ------------------------------------
+// 8 bits, non entrelacé, types 0/2/3/4/6 : c'est ce qu'écrivent Chrome, macOS et Windows pour
+// une capture. Le reste (16 bits, entrelacé) est refusé en le disant. L'alpha est composité
+// sur du BLANC — même règle qu'`avatarFromFile` dans l'app : une capture transparente sortirait
+// noire dans un JPEG, et grise dans l'export.
+function pngDecode(buf){
+  let i = 8, w = 0, h = 0, depth = 0, ct = 0, inter = 0, plte = null;
+  const idat = [];
+  while(i + 8 <= buf.length){
+    const len = buf.readUInt32BE(i), type = buf.toString("latin1", i + 4, i + 8);
+    const data = buf.subarray(i + 8, i + 8 + len);
+    if(type === "IHDR"){ w = data.readUInt32BE(0); h = data.readUInt32BE(4); depth = data[8]; ct = data[9]; inter = data[12]; }
+    else if(type === "PLTE") plte = data;
+    else if(type === "IDAT") idat.push(data);
+    else if(type === "IEND") break;
+    i += 12 + len;
+  }
+  if(!w || !h) throw new Error("the PNG has no IHDR");
+  if(depth !== 8) throw new Error("a " + depth + "-bit PNG — only 8-bit PNGs can be re-encoded here");
+  if(inter) throw new Error("an interlaced PNG cannot be re-encoded here");
+  const ch = { 0:1, 2:3, 3:1, 4:2, 6:4 }[ct];
+  if(!ch || (ct === 3 && !plte)) throw new Error("unsupported PNG colour type " + ct);
+  const raw = inflateSync(Buffer.concat(idat));
+  const stride = w * ch, rgb = new Uint8Array(w * h * 3);
+  let prev = new Uint8Array(stride), cur = new Uint8Array(stride), p = 0;
+  for(let y = 0; y < h; y++){
+    const f = raw[p++];
+    for(let x = 0; x < stride; x++){
+      const a = x >= ch ? cur[x - ch] : 0, b = prev[x], c = x >= ch ? prev[x - ch] : 0;
+      let v = raw[p++];
+      if(f === 1) v += a; else if(f === 2) v += b; else if(f === 3) v += (a + b) >> 1;
+      else if(f === 4){ const pa = Math.abs(b - c), pb = Math.abs(a - c), pc = Math.abs(a + b - 2 * c); v += (pa <= pb && pa <= pc) ? a : (pb <= pc ? b : c); }
+      cur[x] = v & 255;
+    }
+    for(let x = 0; x < w; x++){
+      const q = x * ch; let r, g, bl, al = 255;
+      if(ct === 0){ r = g = bl = cur[q]; }
+      else if(ct === 4){ r = g = bl = cur[q]; al = cur[q + 1]; }
+      else if(ct === 2){ r = cur[q]; g = cur[q + 1]; bl = cur[q + 2]; }
+      else if(ct === 6){ r = cur[q]; g = cur[q + 1]; bl = cur[q + 2]; al = cur[q + 3]; }
+      else { const k = cur[q] * 3; r = plte[k]; g = plte[k + 1]; bl = plte[k + 2]; }
+      if(al < 255){ r = (r * al + 255 * (255 - al)) / 255 | 0; g = (g * al + 255 * (255 - al)) / 255 | 0; bl = (bl * al + 255 * (255 - al)) / 255 | 0; }
+      const o = (y * w + x) * 3; rgb[o] = r; rgb[o + 1] = g; rgb[o + 2] = bl;
+    }
+    const t = prev; prev = cur; cur = t;
+  }
+  return { w, h, rgb };
+}
+// Moyenne de zone : chaque pixel de sortie est la moyenne du rectangle source qu'il couvre.
+// C'est ce qui garde lisible le texte d'une capture réduite d'un facteur 3 — un simple
+// sous-échantillonnage saute des lignes de texte entières.
+function rgbScale(src, W, H){
+  const { w, h, rgb } = src, out = new Uint8Array(W * H * 3);
+  for(let Y = 0; Y < H; Y++){
+    const y0 = Math.floor(Y * h / H), y1 = Math.max(y0 + 1, Math.floor((Y + 1) * h / H));
+    for(let X = 0; X < W; X++){
+      const x0 = Math.floor(X * w / W), x1 = Math.max(x0 + 1, Math.floor((X + 1) * w / W));
+      let r = 0, g = 0, b = 0, n = 0;
+      for(let y = y0; y < y1; y++){ let o = (y * w + x0) * 3; for(let x = x0; x < x1; x++){ r += rgb[o]; g += rgb[o + 1]; b += rgb[o + 2]; o += 3; n++; } }
+      const q = (Y * W + X) * 3; out[q] = r / n | 0; out[q + 1] = g / n | 0; out[q + 2] = b / n | 0;
+    }
+  }
+  return { w: W, h: H, rgb: out };
+}
+const CRC_T = (()=>{ const t = new Int32Array(256); for(let n = 0; n < 256; n++){ let c = n; for(let k = 0; k < 8; k++) c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1); t[n] = c; } return t; })();
+function crc32(buf){ let c = -1; for(let i = 0; i < buf.length; i++) c = CRC_T[(c ^ buf[i]) & 255] ^ (c >>> 8); return (c ^ -1) >>> 0; }
+function pngEncode(img){
+  const { w, h, rgb } = img;
+  const raw = Buffer.alloc((w * 3 + 1) * h);
+  for(let y = 0; y < h; y++){ raw[y * (w * 3 + 1)] = 0; raw.set(rgb.subarray(y * w * 3, (y + 1) * w * 3), y * (w * 3 + 1) + 1); }
+  const chunk = (type, data)=>{
+    const out = Buffer.alloc(12 + data.length);
+    out.writeUInt32BE(data.length, 0); out.write(type, 4, "latin1"); data.copy(out, 8);
+    out.writeUInt32BE(crc32(out.subarray(4, 8 + data.length)), 8 + data.length);
+    return out;
+  };
+  const ihdr = Buffer.alloc(13); ihdr.writeUInt32BE(w, 0); ihdr.writeUInt32BE(h, 4); ihdr[8] = 8; ihdr[9] = 2;
+  return Buffer.concat([Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]), chunk("IHDR", ihdr), chunk("IDAT", deflateSync(raw, { level: 9 })), chunk("IEND", Buffer.alloc(0))]);
+}
+
+// --- Les encodeurs, et l'ordre dans lequel on les essaie ---------------------------------
+// `TABTREE_IMG_ENCODER` force un chemin (js | sips | magick) — c'est ce qui permet au test
+// d'exercer le chemin pur JS sur une machine qui a `sips`, et à qui veut un rendu identique
+// sur toutes ses machines de le demander.
+function encoders(){
+  const want = String(process.env.TABTREE_IMG_ENCODER || "").trim();
+  if(want) return [want];
+  return platform() === "darwin" ? ["sips", "magick", "js"] : ["magick", "js"];
+}
+function withTmpFiles(fn){
+  const dir = mkdtempSync(join(tmpdir(), "tabtree-img-"));
+  try{ return fn(dir); }
+  finally{ try{ rmSync(dir, { recursive:true, force:true }); }catch(e){} }
+}
+// Rend { buf, kind, w, h } ou lève. `long` = côté long visé.
+function encodeWith(name, buf, info, long){
+  if(name === "js"){
+    if(info.kind !== "png") throw new Error("the built-in encoder only reads PNG");
+    const src = pngDecode(buf);
+    const k = Math.min(1, long / Math.max(src.w, src.h));
+    const W = Math.max(1, Math.round(src.w * k)), H = Math.max(1, Math.round(src.h * k));
+    const out = pngEncode(k < 1 ? rgbScale(src, W, H) : src);
+    return { buf: out, kind:"png", w: W, h: H };
+  }
+  return withTmpFiles(dir=>{
+    const inp = join(dir, "in." + (info.kind === "jpeg" ? "jpg" : info.kind)), outp = join(dir, "out.jpg");
+    writeFileSync(inp, buf);
+    if(name === "sips"){
+      execFileSync("sips", ["-Z", String(long), "-s", "format", "jpeg", "-s", "formatOptions", String(IMG_JPEG_Q), inp, "--out", outp], { stdio:"ignore", timeout: 20000 });
+    } else if(name === "magick"){
+      const bin = ["magick", "convert"];
+      let ok = false, last = null;
+      for(const b of bin){
+        try{ execFileSync(b, [inp, "-resize", long + "x" + long + ">", "-quality", String(IMG_JPEG_Q), outp], { stdio:"ignore", timeout: 20000 }); ok = true; break; }
+        catch(e){ last = e; }
+      }
+      if(!ok) throw last || new Error("ImageMagick is not installed");
+    } else throw new Error("unknown encoder " + name);
+    const out = readFileSync(outp), oi = imageInfo(out);
+    if(!oi || oi.kind !== "jpeg") throw new Error(name + " produced no JPEG");
+    return { buf: out, kind:"jpeg", w: oi.w, h: oi.h };
+  });
+}
+
+// --- La porte : un fichier ou une data URL → une couverture que l'app acceptera ---------
+// Rend { img, note } — `note` dit ce qui a été fait, pour la réponse : une image ré-encodée
+// à l'insu de Claude serait une capture qu'il croit envoyer en pleine résolution.
+function readImageSpec(spec, where){
+  if(!spec || typeof spec !== "object") throw new Error(`${where}: give \`file\` (a path on this machine) or \`data\` (a data:image/… URL).`);
+  if(typeof spec.data === "string" && spec.data){
+    const m = /^data:image\/(png|jpeg|jpg|webp|gif);base64,([A-Za-z0-9+/=\s]+)$/.exec(spec.data.trim());
+    if(!m) throw new Error(`${where}: \`data\` must be a data:image/(png|jpeg|webp|gif);base64,… URL.`);
+    return { buf: Buffer.from(m[2].replace(/\s+/g, ""), "base64"), label: "inline image" };
+  }
+  if(typeof spec.file === "string" && spec.file.trim()){
+    const p = resolve(spec.file.trim());
+    if(!existsSync(p)) throw new Error(`${where}: no file at ${p}. Save the screenshot to disk first (a PNG), then pass its full path.`);
+    const st = statSync(p);
+    if(!st.isFile()) throw new Error(`${where}: ${p} is not a file.`);
+    if(st.size > IMG_FILE_MAX) throw new Error(`${where}: ${basename(p)} is ${(st.size / 1048576).toFixed(0)} MB — too large for a screenshot (40 MB max).`);
+    return { buf: readFileSync(p), label: basename(p) };
+  }
+  throw new Error(`${where}: give \`file\` (a path on this machine) or \`data\` (a data:image/… URL).`);
+}
+function coverFrom(spec, where){
+  const { buf, label } = readImageSpec(spec, where);
+  const info = imageInfo(buf);
+  if(!info) throw new Error(`${where}: ${label} is not a PNG, JPEG, WebP or GIF image.`);
+  const long = Math.max(info.w, info.h);
+  const src = `${info.w}×${info.h} ${info.kind.toUpperCase()}`;
+  // Tel quel quand ça tient DÉJÀ — le budget et la taille : ré-encoder une image qui va bien
+  // ne ferait que la dégrader.
+  if(long && long <= IMG_LONG){
+    const d = dataUrlOf(buf, info.kind);
+    if(d.length <= IMG_BUDGET && okCover(d)) return { img: d, note: `${label} (${src}, ${Math.round(d.length / 1024)} KB, kept as is)` };
+  }
+  const tried = [];
+  for(const step of IMG_STEPS){
+    if(long && step > long && step !== IMG_STEPS[IMG_STEPS.length - 1]) continue;   // ne pas « réduire » vers plus grand
+    for(const enc of encoders()){
+      let out;
+      try{ out = encodeWith(enc, buf, info, step); }
+      catch(e){ tried.push(enc + "@" + step + ": " + (e && e.message || e).split("\n")[0]); continue; }
+      const d = dataUrlOf(out.buf, out.kind);
+      if(d.length <= IMG_BUDGET && okCover(d))
+        return { img: d, note: `${label} (${src} → ${out.w}×${out.h} ${out.kind.toUpperCase()}, ${Math.round(d.length / 1024)} KB, via ${enc})` };
+      tried.push(enc + "@" + step + ": " + Math.round(d.length / 1024) + " KB, over the " + Math.round(IMG_BUDGET / 1024) + " KB budget");
+    }
+  }
+  throw new Error(`${where}: ${label} (${src}) could not be brought under ${Math.round(IMG_BUDGET / 1024)} KB. `
+    + (info.kind === "png" ? "Crop it to the part that matters, or " : "Save it as a PNG (the built-in encoder only reads PNG), or ")
+    + "install ImageMagick. Tried: " + tried.join("; "));
+}
+// Pose les captures d'une carte NEUVE : chaque entrée désigne un nœud par son texte (ou un
+// chemin « Parent > Nœud »), exactement comme une proposition — une désignation qui touche deux
+// nœuds est refusée, jamais devinée. Une capture REMPLACE une illustration `pic` : deux images
+// sur un nœud seraient deux vérités pour une question, et c'est `deserialize` qui trancherait.
+function applyImages(root, images){
+  if(images == null) return [];
+  if(!Array.isArray(images)) throw new Error("`images` must be a list of { target, file } (or { target, data }).");
+  if(images.length > 60) throw new Error("Too many screenshots in one map (60 max).");
+  const notes = [];
+  images.forEach((im, i)=>{
+    const where = "images[" + i + "]";
+    const target = String((im && im.target) == null ? "" : im.target);
+    const r = propFind(root, target);
+    if(r.error === "empty")   throw new Error(`${where}: \`target\` is required — the exact text of the node the screenshot goes on.`);
+    if(r.error === "missing") throw new Error(`${where}: no node "${target}" in this outline. Use the exact wording of a line (without its bullet, checkbox or @-marker).`);
+    if(r.error === "ambiguous") throw new Error(`${where}: "${target}" matches ${r.count} nodes. Name an ancestor too, e.g. "Parent > ${parts_last(target)}".`);
+    const { img, note } = coverFrom(im, where);
+    r.node.img = img;
+    if(r.node.pic) delete r.node.pic;
+    notes.push("“" + String(r.node.text || "").slice(0, 60) + "” ← " + note);
+  });
+  return notes;
+}
+
 // ---------------------------------------------------------------------------
 // Désignation d'un nœud (partagé mot pour mot avec l'app — voir tabtree-mcp.test.mjs)
 //
@@ -226,14 +523,48 @@ function propFind(root, spec){
 // ---------------------------------------------------------------------------
 // Arbre → markdown (lecture d'une carte)
 // ---------------------------------------------------------------------------
-function nodeToMarkdown(n, depth){
+// Les marqueurs ⟪…⟫ disent ce qu'un plan ne montre pas (2026-10-12) : les dépendances (par le
+// TEXTE du nœud attendu, résolu ici — Claude ne lit pas des ids), la récurrence, le nombre de
+// commentaires et l'estimation. Sans eux, Claude proposerait une date avant celle du
+// prédécesseur ou cocherait une tâche qui repart aussitôt, sans rien savoir de ce qu'il fait.
+const RECUR_LABEL = { d:"daily", wd:"weekdays", w:"weekly", "2w":"every 2 weeks", m:"monthly", q:"quarterly", y:"yearly" };
+function durText(sec){ const m = Math.round(sec / 60), h = Math.floor(m / 60); return h ? (h + "h" + (m % 60 ? String(m % 60).padStart(2, "0") : "")) : (m + "m"); }
+// `ctx` (1.5.0) : ce que la carte sait du KANBAN et des autres cartes — la colonne de chaque carte,
+// son responsable, ses dates, sa priorité, ses étiquettes, et le NOM de la carte qu'un lien `map:`
+// ouvre (un board attaché à une carte kanban se lit « ⟪opens “Vision” [board]⟫ », pas « map:x7 »).
+function nodeToMarkdown(n, depth, ctx){
   const lines = [];
+  const cx = ctx || {};
+  const colName = new Map(((cx.cols) || []).map(k => [k.id, k]));
+  const doneCol = ((cx.cols) || []).find(k => k.done) || null;
+  const byId = new Map();
+  (function idx(node){ if(node && node.id) byId.set(node.id, node); (node.children||[]).forEach(idx); })(n);
   (function walk(node, d){
     let bullet;
     if(d===0) bullet = "# ";
     else bullet = "  ".repeat(d-1) + (node.check!=null ? (node.check ? "- [x] " : "- [ ] ") : "- ");
-    const body = node.link ? `[${node.text}](${node.link})` : node.text;
-    lines.push(bullet + body + (node.note && node.note.trim() ? "  ⟪note⟫" : ""));
+    const mlink = /^map:([A-Za-z0-9_]+)$/.exec(String(node.link || ""));
+    const linked = mlink && cx.maps ? cx.maps.get(mlink[1]) : null;
+    const body = node.link && !mlink ? `[${node.text}](${node.link})` : node.text;
+    const marks = [];
+    if(mlink) marks.push(linked ? "⟪opens “" + linked.name + "” [" + linked.kind + "]⟫" : "⟪opens another map (" + mlink[1] + ")⟫");
+    if(d > 0 && colName.size){
+      if(node.check === true && doneCol && node.col) marks.push("⟪column: " + doneCol.name + "⟫");
+      else if(node.col && colName.has(node.col)) marks.push("⟪column: " + colName.get(node.col).name + "⟫");
+    }
+    if(typeof node.assign === "string" && node.assign.trim()) marks.push("⟪owner: " + node.assign.trim() + "⟫");
+    if(node.start || node.due) marks.push("⟪" + (node.start && node.due ? node.start + " → " + node.due : node.due ? "due " + node.due : "starts " + node.start) + "⟫");
+    if(Number.isInteger(node.priority) && node.priority > 0) marks.push("⟪P" + node.priority + "⟫");
+    if(Array.isArray(node.tags) && node.tags.length) marks.push("⟪labels: " + node.tags.map(t => (cx.tagNames && cx.tagNames[t]) ? t + " “" + cx.tagNames[t] + "”" : t).join(", ") + "⟫");
+    if(node.note && node.note.trim()) marks.push("⟪note⟫");
+    if(Array.isArray(node.deps) && node.deps.length){
+      const names = node.deps.map(id => byId.get(id)).filter(Boolean).map(p => String(p.text || "").trim()).filter(Boolean);
+      if(names.length) marks.push("⟪waits on: " + names.join(", ") + "⟫");
+    }
+    if(node.recur && RECUR_LABEL[node.recur]) marks.push("⟪repeats " + RECUR_LABEL[node.recur] + "⟫");
+    if(Array.isArray(node.cmts) && node.cmts.length) marks.push("⟪" + node.cmts.length + " comment" + (node.cmts.length > 1 ? "s" : "") + "⟫");
+    if(typeof node.est === "number" && node.est > 0) marks.push("⟪est " + durText(node.est) + "⟫");
+    lines.push(bullet + body + (marks.length ? "  " + marks.join(" ") : ""));
     (node.children||[]).forEach(c=>walk(c, d+1));
   })(n, depth||0);
   return lines.join("\n");
@@ -454,8 +785,17 @@ function readManifest(){
       while(f && !seen.has(f.id) && out.length <= 16){ seen.add(f.id); out.unshift(f.name); f = f.parentId ? folders.get(f.parentId) : null; }
       return out.length ? out.join(" / ") : null;
     };
+    // Un ONGLET (2026-09-15) est un document CACHÉ de la bibliothèque : `sub` porte l'id de son
+    // classeur. Sans le lire, Claude verrait « Sheet 2 » comme une carte ordinaire, sans savoir
+    // de quel classeur elle est la seconde page — et proposerait de la ranger, ou de la lier.
+    const byId = new Map((m.maps||[]).filter(x=>x && x.id).map(x=>[x.id, x]));
+    const okId = v => typeof v === "string" && /^[A-Za-z0-9_]{1,64}$/.test(v);
     const byFile = new Map();
-    (m.maps||[]).forEach(x=>{ if(x && x.file) byFile.set(x.file, { name:x.name, folder: pathOf(x.folderId) }); });
+    (m.maps||[]).forEach(x=>{
+      if(!x || !x.file) return;
+      const book = okId(x.sub) && x.sub !== x.id ? byId.get(x.sub) : null;
+      byFile.set(x.file, { name:x.name, folder: pathOf(x.folderId), tabOf: book ? (book.name || book.id) : null });
+    });
     return byFile;
   }catch(e){ return new Map(); }
 }
@@ -486,6 +826,7 @@ function scanLibrary(){
         file: rel,
         name: meta.name || ent.name.replace(/\.(tabtree|ygmind|json)$/i, "").replace(/__map[A-Za-z0-9_]+$/, ""),
         folder: meta.folder || folder || null,
+        tabOf: meta.tabOf || null,   // le classeur dont ce document est un onglet, sinon null
         kind: doc.board ? "board" : "map",
         nodes: countNodes(doc.root),
         elements: doc.board ? ((doc.shapes||[]).length + (doc.stickies||[]).length + (doc.arrows||[]).length + (doc.draws||[]).length) : undefined,
@@ -499,26 +840,56 @@ function scanLibrary(){
   return out;
 }
 // La bibliothèque du COMPTE, présentée exactement comme celle du dossier : mêmes champs, donc
-// les six outils n'ont rien à savoir de la source. `file` porte la clé de la carte (map_key),
-// que `propose_changes` renvoie telle quelle — pas de suffixe « __id » à analyser ici.
+// les outils n'ont rien à savoir de la source. `file` est l'identifiant que l'APP donne à la carte
+// (≡ `teamLocalId`) : sa clé pour une carte à moi, « T<10 hexa du propriétaire>_<clé> » pour une
+// carte d'équipe — c'est lui qu'une proposition doit porter, l'app le cherche dans SA bibliothèque.
+//
+// ⚠️ PAGINÉE (1.5.0) : la version précédente lisait 300 documents et s'arrêtait EN SILENCE — la
+//    recherche ratait des cartes sur un gros compte sans le dire. On boucle jusqu'au `total`.
+function teamLocalId(owner, key){
+  const t = String(owner || "").replace(/-/g, "").toLowerCase().slice(0, 10);
+  if(!/^[0-9a-f]{10}$/.test(t) || !/^[A-Za-z0-9_]{1,52}$/.test(String(key || ""))) return null;
+  return "T" + t + "_" + key;
+}
+let cloudSpacesCache = null;   // les espaces vus au dernier chargement — la création les résout par nom
 async function cloudLibrary(){
-  const j = await cloudCall("docs", {});
-  const folders = new Map((j.folders||[]).filter(f=>f && f.folder_key).map(f=>[f.folder_key, f]));
-  const pathOf = (k)=>{
+  const pages = [];
+  let total = Infinity, off = 0, j = null;
+  while(off < total && off < 5000){
+    j = await cloudCall("docs", { limit: 100, offset: off });
+    const got = j.maps || [];
+    pages.push(...got);
+    total = typeof j.total === "number" ? j.total : got.length;   // edge function d'avant la 1.5.0 : une seule page
+    if(!got.length || typeof j.total !== "number") break;
+    off += got.length;
+  }
+  const me = (j && j.me) || null;
+  cloudSpacesCache = (j && j.spaces) || [];
+  const spaceName = (owner, key)=>{ const sp = cloudSpacesCache.find(x=>x.owner === owner && x.space_key === key); return sp ? sp.name : null; };
+  const folders = new Map((j && j.folders || []).filter(f=>f && f.folder_key).map(f=>[(f.owner || "") + "|" + f.folder_key, f]));
+  const pathOf = (owner, k)=>{
     const out = [], seen = new Set();
-    let f = folders.get(k);
-    while(f && !seen.has(f.folder_key) && out.length <= 16){ seen.add(f.folder_key); out.unshift(f.name); f = f.parent_key ? folders.get(f.parent_key) : null; }
+    let f = folders.get((owner || "") + "|" + k) || folders.get("|" + k);
+    while(f && !seen.has(f.folder_key) && out.length <= 16){ seen.add(f.folder_key); out.unshift(f.name); f = f.parent_key ? (folders.get((owner || "") + "|" + f.parent_key) || folders.get("|" + f.parent_key)) : null; }
     return out.length ? out.join(" / ") : null;
   };
   const out = [];
-  for(const r of (j.maps||[])){
+  for(const r of pages){
     const doc = r && r.doc;
     if(!doc || !doc.root) continue;
+    const owner = r.owner || me;
+    const team = !!(owner && me && owner !== me);
+    const file = team ? teamLocalId(owner, r.map_key) : r.map_key;
+    if(!file) continue;
     out.push({
-      file: r.map_key,
+      file, key: r.map_key, owner, team,
+      role: r.role || "owner",
+      space: r.space_key ? spaceName(owner, r.space_key) : null,
       name: String(r.name || "") || String(doc.root.text || "").slice(0, 60) || r.map_key,
-      folder: pathOf(r.folder_key),
-      kind: doc.board ? "board" : "map",
+      folder: pathOf(owner, r.folder_key),
+      // La SORTE de l'index (kanban, note, gantt, sheet) quand le compte la dit : c'est elle qui décide
+      // de la vue d'ouverture dans l'app. Le document seul ne distingue que board / carte.
+      kind: doc.board ? "board" : (r.kind && r.kind !== "board" ? r.kind : "map"),
       nodes: countNodes(doc.root),
       elements: doc.board ? ((doc.shapes||[]).length + (doc.stickies||[]).length + (doc.arrows||[]).length + (doc.draws||[]).length) : undefined,
       mtime: String(r.updated_at || "").slice(0,16).replace("T"," "),
@@ -573,19 +944,70 @@ async function findMap(file){
 // ---------------------------------------------------------------------------
 // Écriture (toujours un NOUVEAU fichier — jamais de modification en place)
 // ---------------------------------------------------------------------------
-async function writeDoc(name, doc, folder){
+async function writeDoc(name, doc, folder, opts){
+  const o = opts || {};
   if(CLOUD){
-    // Le dossier est un NOM de dossier de bibliothèque : on le résout en clé s'il existe déjà,
-    // sinon la carte arrive à la racine et le texte de réponse le dit (« no silent caps »).
-    let folder_key = null;
+    // Le dossier est un NOM ou un CHEMIN de dossier de bibliothèque : on le résout en clé s'il
+    // existe déjà, sinon la carte arrive à la racine et le texte de réponse le dit
+    // (« no silent caps »).
+    //
+    // ⚠️ 2026-09-23 — LE NOM SEUL NE SUFFIT PAS. Un compte qui a « Ai4X » à la racine ET un « Ai4X »
+    // imbriqué dedans faisait tirer au sort. Deux règles : un CHEMIN complet (« Ai4X / Ai4X ») gagne
+    // toujours, et un nom seul prend le dossier le MOINS PROFOND. L'ambiguïté est dite.
+    //
+    // 👥 1.5.0 — LES ESPACES D'ÉQUIPE. `space` (un nom d'espace) dit OÙ : un de mes espaces, ou un
+    // espace dont je suis membre — la carte vit alors chez son PROPRIÉTAIRE, comme toute carte
+    // d'équipe. Les dossiers candidats sont ceux de cet espace ; sans `space`, mes dossiers d'abord,
+    // puis ceux des espaces d'équipe (un dossier d'équipe se désigne aussi par son chemin).
+    const j = await cloudCall("list", {});
+    const me = j.me || null;
+    const spaces = (j.spaces || []).filter(x=>x && x.space_key);
+    const all = (j.folders || []).filter(f=>f && f.folder_key);
+    const byKey = new Map(all.map(f=>[(f.owner || "") + "|" + f.folder_key, f]));
+    const chain = (f0)=>{ const out=[]; const seen=new Set(); let f=f0;
+      while(f && !seen.has(f.folder_key) && out.length<=16){ seen.add(f.folder_key); out.unshift(f.name); f = f.parent_key ? byKey.get((f.owner || "") + "|" + f.parent_key) : null; }
+      return out; };
+    const norm = (x)=>String(x||"").split("/").map(t=>t.trim()).filter(Boolean).join(" / ").toLowerCase();
+    let sp = null;
+    if(o.space){
+      const want = norm(o.space);
+      const hits = spaces.filter(x=>norm(x.name) === want);
+      if(!hits.length) throw new Error("No space named “" + o.space + "” in this account" + (spaces.length ? ". Spaces you can use: " + spaces.map(x=>"“" + x.name + "”" + (x.owner !== me ? " (team, " + x.role + ")" : "")).join(", ") : " — it has no spaces") + ".");
+      sp = hits.find(x=>x.owner === me) || hits[0];
+      if(!sp.writable) throw new Error("You cannot add maps to the space “" + sp.name + "” — " + (sp.role === "viewer" ? "your role there is viewer. Ask its owner for the editor role." : "its owner's plan has ended, so it is read-only."));
+    }
+    let f0 = null, folder_twins = 0;
     if(folder){
-      const j = await cloudCall("list", {});
-      const hit = (j.folders||[]).find(f=>f && String(f.name||"").trim().toLowerCase() === String(folder).trim().toLowerCase());
-      if(hit) folder_key = hit.folder_key;
+      const want = norm(folder);
+      let cands = all.filter(f=>!sp || (f.owner === sp.owner && f.space_key === sp.space_key));
+      if(!sp) cands = cands.slice().sort((a,b)=>(a.owner === me ? 0 : 1) - (b.owner === me ? 0 : 1));
+      let hits = cands.filter(f=>norm(chain(f).join(" / ")) === want);                       // chemin exact
+      if(!hits.length) hits = cands.filter(f=>norm(f.name) === want)                         // nom de feuille
+                                  .sort((a,b)=>((a.owner === me ? 0 : 1) - (b.owner === me ? 0 : 1)) || (chain(a).length - chain(b).length));
+      if(hits.length){ f0 = hits[0]; folder_twins = hits.length; }
+    }
+    const owner = f0 ? (f0.owner || me) : (sp ? sp.owner : me);
+    const kind = o.kind || (doc.board ? "board" : (doc.kanban ? "kanban" : "map"));
+    const body = { name: String(name||"").slice(0,200), kind, doc, folder_key: f0 ? f0.folder_key : null };
+    if(owner && me && owner !== me) body.owner = owner;
+    if(!f0 && sp) body.space_key = sp.space_key;
+    const r = await cloudCall("create", body);
+    // On DIT toujours où la carte a atterri : l'espace, le chemin complet — pas le nom demandé.
+    const spaceOf = (own, key)=>{ const x = spaces.find(y=>y.owner === own && y.space_key === key); return x ? x.name : null; };
+    const inSpace = f0 ? spaceOf(f0.owner, f0.space_key) : (sp ? sp.name : null);
+    let where = "";
+    if(f0){
+      where = "  (in “" + chain(f0).join(" / ") + "”" + (inSpace ? ", space “" + inSpace + "”" : "") + ")";
+      if(folder_twins > 1) where += "  ⚠ " + folder_twins + " folders are named “" + folder
+        + "” in this account; the shallowest was used. Pass the full path (e.g. “" + folder + " / " + folder
+        + "”) to choose another one.";
+    } else if(folder){
+      where = "  (folder “" + folder + "” does not exist" + (sp ? " in the space “" + sp.name + "”" : " in this account") + " — the map is at the root" + (sp ? " of that space" : "") + ")";
+    } else if(sp){
+      where = "  (space “" + sp.name + "”" + (owner !== me ? " — a team space: every member sees it" : "") + ")";
     }
-    const kind = doc.board ? "board" : (doc.kanban ? "kanban" : "map");
-    const r = await cloudCall("create", { name: String(name||"").slice(0,200), kind, doc, folder_key });
-    return "cloud:" + r.map_key + (folder && !folder_key ? "  (folder “" + folder + "” does not exist in this account — the map is at the root)" : "");
+    const id = (owner && me && owner !== me) ? teamLocalId(owner, r.map_key) : r.map_key;
+    return "cloud:" + (id || r.map_key) + where;
   }
   dirOk();
   let target = DIR;
@@ -616,20 +1038,78 @@ function countForest(roots){ return roots.reduce((n,r)=>n + countNodes(r), 0); }
 // connecteur la refuserait à l'écriture, ou l'app la jetterait à la lecture — dans les deux
 // cas Claude croirait avoir proposé quelque chose qui n'arrive jamais chez l'utilisateur.
 // C'est le défaut du losange, rejoué. Un test compare les deux listes en ensembles.
-const PROP_OPS = ["add","rename","note","check","delete","move","pic","persona"];
+const PROP_OPS = ["add","rename","note","check","delete","move","pic","img","persona","tags","assign","priority","due","attr","comment","est","start","cols","link"];
+// ⚡ Les ops que l'app applique D'ELLE-MÊME (1.5.0, décidé « hybride » le 2026-10-20) — ≡
+// `PROP_AUTO_OPS` d'app/index.html (le test compare les deux). Plus `cols` quand le tableau n'a
+// pas encore de colonnes (`seed`). C'est l'APP qui décide : le connecteur ne fait que demander
+// (`auto:true`) et découper le lot pour que le reste parte à la revue.
+const PROP_AUTO_OPS = ["add","move","check","tags","assign","priority","due","start","est","attr","comment","pic","img","link"];
+// Les ops que Claude peut ÉCRIRE et qui n'existent pas telles quelles dans l'app : `lever` devient
+// un attribut « Lever: <clé> » (c'est ainsi que l'app le range, `KB_LEVER_ATTR`), `columns` est le
+// nom lisible de `cols`.
+const INPUT_OPS = PROP_OPS.concat(["lever", "columns"]);
+// Les quatre leviers Ai4X — ≡ les clés de `KB_LEVERS` d'app/index.html (le test compare).
+const KB_LEVER_KEYS_MCP = ["human","think","accelerate","automate"];
+// Un identifiant de nœud neuf, de la forme qu'`okNodeId` accepte. Posé sur chaque `add` (`nid`) :
+// c'est ce qui rend l'ajout IDEMPOTENT dans l'app — rejoué par deux appareils, il ne double pas.
+function newNid(){ return "mcp" + Date.now().toString(36) + Math.random().toString(36).slice(2, 8); }
+function cloneDoc(d){ return JSON.parse(JSON.stringify(d)); }
+// Les dix étiquettes de couleur du kanban — ≡ `KB_TAGS` de index.html (le test compare les deux).
+const KB_TAG_KEYS = ["green","yellow","orange","red","purple","blue","sky","lime","pink","gray"];
 
 // Tout est vérifié ICI, contre la carte réelle, et un défaut fait ÉCHOUER l'appel. C'est
 // délibéré : une cible introuvable remonte à Claude, qui peut relire la carte et corriger,
 // alors qu'une proposition à moitié valide arriverait chez l'utilisateur sous forme de
 // lignes barrées qu'il ne peut ni comprendre ni réparer. La boîte aux lettres ne reçoit
 // que des propositions applicables.
-function buildProposalOps(mapDoc, changes){
+// ⚠️ SÉQUENTIEL depuis la 1.5.0 : chaque op est validée contre la carte TELLE QUE LES OPS
+//    PRÉCÉDENTES L'ONT LAISSÉE (une copie, `work`). Sans ça, « ajoute la carte X, puis mets-lui une
+//    échéance » échouait : X n'existait pas encore dans la carte lue. L'app applique dans le même
+//    ordre, donc la cible validée ici est celle qu'elle trouvera.
+function buildProposalOps(mapDoc0, changes){
   if(!Array.isArray(changes) || !changes.length) throw new Error("`changes` must be a non-empty list.");
   if(changes.length > 100) throw new Error("Too many changes in one proposal (max 100). Send several smaller ones — the user reviews them one by one.");
+  const mapDoc = cloneDoc(mapDoc0);
+  const colsNow = ()=>(mapDoc.kanban && Array.isArray(mapDoc.kanban.cols) && mapDoc.kanban.cols.length) ? mapDoc.kanban.cols : null;
+  // Une colonne se désigne par son id OU par son nom (« Doing ») — Claude lit les noms.
+  const colRef = (raw, where)=>{
+    const cols = colsNow();
+    const v = String(raw);
+    if(!cols) throw new Error(`${where}: this map has no kanban board yet. Add a "columns" change first (e.g. { op: "columns", columns: [{ name: "To do" }, { name: "Doing" }, { name: "Done", done: true }] }), then refer to those column names.`);
+    const hit = cols.find(k => k.id === v) || cols.find(k => String(k.name).trim().toLowerCase() === v.trim().toLowerCase());
+    if(!hit) throw new Error(`${where}: no column "${v}" on this board. Use one of: ${cols.map(k => `"${k.name}" (${k.id})`).join(", ")}.`);
+    return hit.id;
+  };
   return changes.map((c, i)=>{
     const where = "change #" + (i+1);
     const op = String((c && c.op) || "").trim();
-    if(!PROP_OPS.includes(op)) throw new Error(`${where}: unknown op "${op}". Use one of: ${PROP_OPS.join(", ")}.`);
+    if(!INPUT_OPS.includes(op)) throw new Error(`${where}: unknown op "${op}". Use one of: ${INPUT_OPS.filter(x=>x !== "cols").join(", ")}.`);
+    if(op === "columns" || op === "cols"){
+      // Les colonnes du tableau, en un bloc. Un tableau qui n'en a PAS reçoit `seed` : l'app pose ces
+      // colonnes d'elle-même, sans écraser celles qu'un collègue aurait posées entre-temps. Un tableau
+      // qui en a déjà : un REMPLACEMENT, qui part à la revue (les cartes d'une colonne retirée
+      // quittent le tableau). Un id existant est GARDÉ quand le nom revient — sinon chaque carte de
+      // « Doing » perdrait sa colonne au passage.
+      const list = Array.isArray(c.columns) ? c.columns : (Array.isArray(c.cols) ? c.cols : null);
+      if(!list || !list.length || list.length > 12) throw new Error(`${where}: \`columns\` must list 1 to 12 columns — { name, done?, wip? }.`);
+      const before = colsNow() || [];
+      const used = new Set();
+      const cols = list.map((k, j)=>{
+        const name = String((k && (k.name != null ? k.name : k)) || "").replace(/[\x00-\x1f\x7f]/g, " ").trim().slice(0, 60);
+        if(!name) throw new Error(`${where}: column #${j+1} has no name.`);
+        const prev = before.find(b => String(b.name).trim().toLowerCase() === name.toLowerCase() && !used.has(b.id));
+        let id = prev ? prev.id : (k && typeof k.id === "string" && /^[\w-]{1,24}$/.test(k.id) && !before.some(b=>b.id === k.id) ? k.id : "c" + (j+1));
+        while(used.has(id) || (!prev && before.some(b => b.id === id))) id = "c" + Math.random().toString(36).slice(2, 7);
+        used.add(id);
+        const wip = parseInt(k && k.wip, 10);
+        return Object.assign({ id, name }, k && k.done ? { done: true } : {}, (wip >= 1 && wip <= 99) ? { wip } : {});
+      });
+      if(cols.filter(k => k.done).length > 1) throw new Error(`${where}: only one column can be the "done" column.`);
+      const out = { op: "cols", cols };
+      if(!before.length) out.seed = true;
+      mapDoc.kanban = Object.assign({}, mapDoc.kanban || {}, { cols });
+      return out;
+    }
     if(op === "persona"){
       // `persona` (2026-09-08) vise le DOCUMENT entier — la toile d'une work map — jamais un
       // nœud : donc pas de `target`. C'est le relais skill → carte sans copier-coller : le skill
@@ -641,11 +1121,18 @@ function buildProposalOps(mapDoc, changes){
       // profondeur — « une proposition à moitié valide arrive en lignes barrées » — ne
       // s'applique pas : une op persona est ATOMIQUE, elle rebâtit la toile ou ne fait rien.
       const P = c.persona;
-      if(!P || typeof P !== "object" || !Array.isArray(P.modules) || !P.modules.length)
-        throw new Error(`${where}: \`persona\` must be the interview object — { who, role, mission, tools, meetings, opener, modules:[{ name, procs:[{ name, h, after, freq, rep, data, stakes, lever, step, why }] }], trajectory, signs, parking }.`);
+      // DEUX personas (2026-09-11) : celui d'une WORK MAP porte des `modules`, celui d'un SECOND
+      // CERVEAU des `domains`. Même contrôle superficiel — `okBrain` juge à l'application.
+      const isBrain = !!(P && typeof P === "object" && Array.isArray(P.domains) && P.domains.length);
+      if(!P || typeof P !== "object" || (!isBrain && (!Array.isArray(P.modules) || !P.modules.length)))
+        throw new Error(`${where}: \`persona\` must be the interview object — a work map { who, role, mission, tools, meetings, opener, modules:[{ name, procs:[{ name, h, after, freq, rep, data, stakes, lever, step, why }] }], trajectory, signs, parking }, or a second-brain blueprint { who, role, mission, tools, opener, domains:[{ name, kind, share, holds }], losses, outputs, sources, nevermix, cadence, review, ailevel, signs }.`);
+      if(JSON.stringify(P).length > 60000) throw new Error(`${where}: the persona is too large (60000 characters max).`);
+      if(isBrain){
+        if(P.domains.length > 5) throw new Error(`${where}: the blueprint has ${P.domains.length} domains — five at most.`);
+        return { op, persona: P, procs: 0, domains: P.domains.length };
+      }
       const n = P.modules.reduce((a, m)=>a + ((m && Array.isArray(m.procs)) ? m.procs.length : 0), 0);
       if(n < 3) throw new Error(`${where}: the persona has ${n} process(es) — a work map needs at least three. Finish the interview first.`);
-      if(JSON.stringify(P).length > 60000) throw new Error(`${where}: the persona is too large (60000 characters max).`);
       return { op, persona: P, procs: n };
     }
     const target = String(c.target == null ? "" : c.target);
@@ -654,6 +1141,14 @@ function buildProposalOps(mapDoc, changes){
     if(r.error === "missing") throw new Error(`${where}: no node "${target}" in this map. Run read_map first and copy the wording exactly.`);
     if(r.error === "ambiguous") throw new Error(`${where}: "${target}" matches ${r.count} nodes. Name an ancestor too, e.g. "Parent > ${parts_last(target)}".`);
     const out = { op, target, was: String(r.node.text||"") };
+    // `why` (2026-10-12) : la RAISON d'un changement, en une ligne — l'app la montre sous la ligne
+    // à approuver. ≡ la règle de `parseProposal` côté app (une ligne, 200 caractères) : une raison
+    // trop longue est rognée, jamais refusée ; une raison qui n'est pas du texte, si.
+    if(c.why != null){
+      if(typeof c.why !== "string") throw new Error(`${where}: \`why\` must be text — one short line saying why this change.`);
+      const w = c.why.replace(/[\x00-\x1f\x7f]/g, " ").replace(/\s+/g, " ").trim().slice(0, 200);
+      if(w) out.why = w;
+    }
     if(op === "add"){
       if(typeof c.markdown !== "string" || !c.markdown.trim()) throw new Error(`${where}: \`markdown\` is required for an "add".`);
       if(c.markdown.length > 20000) throw new Error(`${where}: \`markdown\` is too long (20000 characters max).`);
@@ -661,18 +1156,35 @@ function buildProposalOps(mapDoc, changes){
       if(!forest.length) throw new Error(`${where}: \`markdown\` has no usable structure (a bullet list, indented by 2 spaces).`);
       out.markdown = c.markdown;
       out.adds = countForest(forest);
+      out.nid = newNid();
+      // `col` facultatif (2026-10-12) : les cartes NEUVES vont dans cette colonne du kanban.
+      // Validé comme pour `move` — une colonne inventée est refusée ICI, en nommant les vraies ;
+      // un NOM de colonne est accepté et traduit en id (1.5.0).
+      if(c.col != null && c.col !== "") out.col = colRef(c.col, where);
+      // La copie de travail reçoit les nœuds : une op suivante du même lot peut les viser.
+      r.node.children = (r.node.children || []).concat(forest);
+      // `assign` facultatif (2026-10-12, 👥) : le RESPONSABLE des cartes neuves. Mêmes bornes que l'op
+      // `assign` ; refusé ICI en le disant, plutôt que de laisser l'app le retirer en silence.
+      if(c.assign != null && c.assign !== ""){
+        if(typeof c.assign !== "string" || c.assign.length > 120 || /[\x00-\x1f\x7f]/.test(c.assign))
+          throw new Error(`${where}: \`assign\` must be a name or e-mail (120 characters max) — the owner of the new cards.`);
+        if(c.assign.trim()) out.assign = c.assign.trim();
+      }
     } else if(op === "rename"){
       if(typeof c.text !== "string" || !c.text.trim()) throw new Error(`${where}: \`text\` is required for a "rename".`);
       out.text = c.text.trim().slice(0, 2000);
+      r.node.text = out.text;
     } else if(op === "note"){
       if(typeof c.note !== "string") throw new Error(`${where}: \`note\` is required for a "note" (an empty string clears it).`);
       out.note = c.note.slice(0, 8000);
     } else if(op === "check"){
-      if(typeof c.value !== "boolean") throw new Error(`${where}: \`value\` must be true or false for a "check".`);
-      out.value = c.value;
+      const v = c.value === "true" ? true : c.value === "false" ? false : c.value;
+      if(typeof v !== "boolean") throw new Error(`${where}: \`value\` must be true or false for a "check".`);
+      out.value = v;
     } else if(op === "delete"){
       if(r.node === mapDoc.root) throw new Error(`${where}: the centre of the map cannot be deleted.`);
       out.drops = countNodes(r.node);
+      (function cut(n){ const k = (n.children || []).indexOf(r.node); if(k >= 0){ n.children.splice(k, 1); return true; } return (n.children || []).some(cut); })(mapDoc.root);
     } else if(op === "pic"){
       // Une désignation, jamais des pixels. La liste est FERMÉE : un id inventé est refusé ICI,
       // contre la carte réelle, plutôt que d'arriver chez l'utilisateur sous forme d'une ligne
@@ -683,35 +1195,138 @@ function buildProposalOps(mapDoc, changes){
           + `or "a:" followed by one of: ${ART_IDS_MCP.join(", ")} — or "" to remove it.`);
       }
       out.pic = pic;
+    } else if(op === "img"){
+      // Des PIXELS, cette fois — ré-encodés ICI pour passer `okCover` chez l'utilisateur. Une
+      // capture trop lourde est refusée à l'écriture, en nommant la limite, plutôt que d'arriver
+      // dans le panneau comme une ligne grisée. `img: ""` retire la capture.
+      if(c.img === "" || c.img === null){ out.img = ""; }
+      else {
+        const { img, note } = coverFrom(c, where);
+        out.img = img; out.shot = note;
+      }
     } else if(op === "move"){
       // ⚠️ Dans le FICHIER les colonnes sont `{cols:[…]}` ; en mémoire, côté app, c'est un
       // tableau nu. Confondre les deux donne un contrôle qui ne regarde rien.
-      const cols = (mapDoc.kanban && Array.isArray(mapDoc.kanban.cols)) ? mapDoc.kanban.cols : null;
-      if(!cols || !cols.length) throw new Error(`${where}: this map has no kanban board yet. Open it in TabTree and press 🃏 once, then try again.`);
-      const col = String(c.col == null ? "" : c.col);
       // Vide = retirer du tableau, comme le ✕ d'une carte. Toute autre valeur doit désigner une
-      // colonne RÉELLE : une carte envoyée ailleurs disparaîtrait de l'écran sans un message.
-      if(col && !cols.some(k => k.id === col)){
-        const noms = cols.map(k => `"${k.name}" (${k.id})`).join(", ");
-        throw new Error(`${where}: no column "${col}" on this board. Use one of: ${noms} — or "" to take the card off the board.`);
-      }
-      out.col = col;
+      // colonne RÉELLE (id ou nom) : une carte envoyée ailleurs disparaîtrait de l'écran sans un message.
+      const raw = String(c.col == null ? "" : c.col);
+      if(!colsNow()) colRef(raw || "?", where);   // lève le message « pas encore de kanban »
+      out.col = raw ? colRef(raw, where) : "";
+    } else if(op === "tags"){
+      // Les dix couleurs, liste FERMÉE — ≡ `okTags` de l'app. Une clé inventée est refusée ICI,
+      // en nommant la liste, plutôt que de tomber en silence à la lecture. [] retire tout.
+      if(!Array.isArray(c.tags)) throw new Error(`${where}: \`tags\` must be a list of label colours for a "tags" (an empty list clears them).`);
+      const bad = c.tags.filter(t => !KB_TAG_KEYS.includes(t));
+      if(bad.length) throw new Error(`${where}: unknown label colour "${bad[0]}". Use any of: ${KB_TAG_KEYS.join(", ")} (read_map shows the names the board gave them).`);
+      out.tags = KB_TAG_KEYS.filter(k => c.tags.includes(k));
+    } else if(op === "assign"){
+      if(typeof c.assign !== "string") throw new Error(`${where}: \`assign\` is required for an "assign" — a name or e-mail (an empty string clears it).`);
+      if(c.assign.length > 120 || /[\x00-\x1f\x7f]/.test(c.assign)) throw new Error(`${where}: \`assign\` is too long or contains control characters (120 characters max).`);
+      out.assign = c.assign.trim();
+    } else if(op === "priority"){
+      const q = (c.priority == null) ? 0 : c.priority;
+      if(!Number.isInteger(q) || q < 0 || q > 6) throw new Error(`${where}: \`priority\` must be a whole number from 1 (highest) to 6, or 0 to remove it.`);
+      out.priority = q;
+    } else if(op === "due" || op === "start"){
+      const q = (c[op] == null) ? "" : String(c[op]);
+      if(q && !/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/.test(q)) throw new Error(`${where}: \`${op}\` must be a day written YYYY-MM-DD (or "" to remove it).`);
+      out[op] = q;
+    } else if(op === "link"){
+      // La liste blanche de l'app (`okOpLink`), en plus étroit : une page web, un e-mail, ou une
+      // autre carte (`map:<id>` — l'id que list_maps donne). Jamais `javascript:` ni `data:`.
+      const q = (c.link == null) ? "" : String(c.link).trim();
+      if(q && !/^(https?:\/\/[^\s\x00-\x1f]+|mailto:[^\s\x00-\x1f]+|map:[A-Za-z0-9_]+)$/i.test(q))
+        throw new Error(`${where}: \`link\` must be an https:// address, a mailto: address, or "map:<file>" to open another map from list_maps (or "" to remove it).`);
+      out.link = q;
+    } else if(op === "lever"){
+      // Le levier Ai4X d'une carte. L'app le range en ATTRIBUT « Lever: <clé> » (`kbLeverSet` →
+      // `shAttrSet`) : on écrit exactement ça, par l'op `attr`, que l'app sait appliquer.
+      const q = String(c.lever == null ? "" : c.lever).trim().toLowerCase();
+      if(q && !KB_LEVER_KEYS_MCP.includes(q)) throw new Error(`${where}: \`lever\` must be one of ${KB_LEVER_KEYS_MCP.join(", ")} (or "" to remove it).`);
+      out.op = "attr"; out.name = "Lever"; out.value = q;
+    } else if(op === "attr"){
+      if(typeof c.name !== "string" || !c.name.trim() || c.name.length > 60 || /[:\x00-\x1f]/.test(c.name))
+        throw new Error(`${where}: \`name\` is required for an "attr" — the attribute's name, without a colon (60 characters max).`);
+      if(typeof c.value !== "string" || c.value.length > 400 || /[\x00-\x1f]/.test(c.value))
+        throw new Error(`${where}: \`value\` is required for an "attr" — its value as text (400 characters max; "" removes the attribute).`);
+      out.name = c.name.trim(); out.value = c.value.trim();
+    } else if(op === "comment"){
+      // Un commentaire est AJOUTÉ au fil de la carte, jamais substitué : la seule op qui ne
+      // réécrit rien. Signé « Claude » par l'app (le `by` de la proposition), borné comme
+      // `CMT_TEXT_MAX` côté app — un fil est lu par des gens, pas par un tableur.
+      if(typeof c.text !== "string" || !c.text.trim()) throw new Error(`${where}: \`text\` is required for a "comment" — what you want to say about this card.`);
+      if(c.text.length > 2000) throw new Error(`${where}: the comment is too long (2000 characters max).`);
+      out.text = c.text.trim();
+    } else if(op === "est"){
+      // Une DURÉE, dans les formes que `parseDur` lit côté app (« 2h », « 1h30 », « 45 » = minutes,
+      // « 2:15 »), jamais une phrase : « soon » est refusé ICI, en nommant les formes, plutôt que
+      // de tomber en silence à la lecture. Vide = retirer l'estimation.
+      const q = (c.est == null) ? "" : String(c.est).trim().toLowerCase().replace(/\s+/g, "");
+      if(q && !DUR_RE.test(q)) throw new Error(`${where}: \`est\` must be a duration — "2h", "1h30", "45" (minutes) or "2:15" — or "" to remove the estimate.`);
+      out.est = q;
     }
     return out;
   });
 }
+// 👥 L'ÉQUIPE du tableau (`kanban.team`, 2026-10-12) — qui fait quoi. Montrée par read_map pour la
+// même raison que dans l'app : c'est elle qui permet de proposer un RESPONSABLE (assign) au lieu de
+// deviner à partir d'un prénom écrit dans un titre. Lecture seule, bornée comme `okKbTeam` côté app
+// (30 personnes, textes rognés) : le fichier vient du disque, c'est-à-dire de n'importe qui.
+function teamToText(doc){
+  const t = doc && doc.kanban && doc.kanban.team;
+  if(!t || typeof t !== "object" || !Array.isArray(t.people)) return "";
+  const line = (v, max) => String(typeof v === "string" ? v : "").replace(/[\x00-\x1f\x7f]+/g, " ").replace(/\s+/g, " ").trim().slice(0, max);
+  const people = t.people.filter(p => p && typeof p.who === "string" && line(p.who, 120)).slice(0, 30);
+  if(!people.length) return "";
+  let out = "\n\n👥 Team — who does what (pick owners from here; `assign` takes the exact name):";
+  const goal = line(t.goal, 800);
+  if(goal) out += "\n  Team objectives: " + goal;
+  for(const p of people){
+    out += "\n• " + line(p.who, 120) + (line(p.role, 80) ? " — " + line(p.role, 80) : "");
+    if(line(p.does, 800)) out += "\n    owns: " + line(p.does, 800);
+    if(line(p.goals, 800)) out += "\n    objectives: " + line(p.goals, 800);
+  }
+  return out;
+}
+// ≡ les formes que `parseDur` accepte dans index.html (hh:mm, Nh, NhMM, Nm, Ns, N = minutes).
+const DUR_RE = /^(\d{1,5}:[0-5]\d|\d{1,5}h([0-5]?\d)?m?|\d{1,7}m(in)?|\d{1,9}s(ec)?|\d{1,7})$/;
 function parts_last(spec){ const p = String(spec||"").split(">"); return p[p.length-1].trim(); }
 
-async function writeProposal(map, note, ops){
-  const payload = (id)=>({
+// L'app ignore un fichier de proposition au-delà de PROP_FILE_MAX octets (`propScan`) — sans un
+// mot, puisqu'elle ne peut pas savoir ce qu'il contenait. Avec des captures d'écran dedans, la
+// borne se rencontre : on refuse ICI en nommant le geste, jamais un dépôt qui n'arrive pas.
+const PROP_FILE_MAX = 1400000;
+// ⚡ LE DÉCOUPAGE « HYBRIDE » (1.5.0). Le début du lot fait d'ops sûres part avec `auto:true` —
+// l'app l'applique d'elle-même ; à partir de la PREMIÈRE op qui demande une revue, tout le reste
+// part dans une seconde proposition, à revoir. Découper AU PREMIER refus, jamais op par op : une
+// op sûre qui suit un renommage vise souvent le texte renommé, et l'appliquer avant lui la ferait
+// échouer chez l'utilisateur.
+function autoOk(o){ return o.op === "cols" ? o.seed === true : PROP_AUTO_OPS.includes(o.op); }
+function splitAuto(ops){
+  let k = 0;
+  while(k < ops.length && autoOk(ops[k])) k++;
+  return { auto: ops.slice(0, k), review: ops.slice(k) };
+}
+async function writeProposal(map, note, ops, opts){
+  const o = opts || {};
+  const payload = (id, list, auto)=>Object.assign({
     v: 1, kind: "tabtree-proposal", mapId: id, mapFile: CLOUD ? map.file : basename(map.file), mapName: map.name,
-    createdAt: Date.now(), by: "Claude", note: String(note||"").slice(0, 2000), ops
-  });
+    createdAt: Date.now(), by: "Claude", note: String(note||"").slice(0, 2000), ops: list
+  }, auto ? { auto: true } : {});
+  const shots = ops.filter(x=>x.op === "img" && x.img).length;
+  if(JSON.stringify(payload("x", ops)).length > PROP_FILE_MAX)
+    throw new Error("This proposal is too large for TabTree's mailbox (" + Math.round(PROP_FILE_MAX / 1024) + " KB max) — it carries " + shots + " screenshot(s). Send it as several proposals with fewer screenshots each.");
   if(CLOUD){
     // La boîte aux lettres cloud : la table `proposals`, que l'app relit au sondage suivant.
     // Même charge utile que le fichier — c'est le même `parseProposal` qui la lit côté app.
-    const r = await cloudCall("propose", { map_key: map.file, payload: payload(map.file) });
-    return "cloud:" + (r.id || "proposal");
+    // Une carte d'équipe : la clé chez son propriétaire, et `mapId` = l'id que l'app lui donne.
+    const parts = o.review ? { auto: [], review: ops } : splitAuto(ops);
+    const base = { map_key: map.key || map.file };
+    if(map.team && map.owner) base.owner = map.owner;
+    const ids = {};
+    if(parts.auto.length){ const r = await cloudCall("propose", Object.assign({ payload: payload(map.file, parts.auto, true) }, base)); ids.auto = r.id || "proposal"; }
+    if(parts.review.length){ const r = await cloudCall("propose", Object.assign({ payload: payload(map.file, parts.review, false) }, base)); ids.review = r.id || "proposal"; }
+    return { auto: parts.auto, review: parts.review, ids };
   }
   dirOk();
   const target = join(DIR, PROP_DIR);
@@ -719,8 +1334,8 @@ async function writeProposal(map, note, ops){
   const id = mapIdOf(map.file);
   if(!id) throw new Error("This map's file has no id suffix (“…__map123.tabtree”), so the app cannot match a proposal to it. Open it once in TabTree with the backup folder turned on, then try again.");
   const file = "prop_" + id + "__" + Date.now().toString(36) + ".json";
-  writeFileSync(join(target, file), JSON.stringify(payload(id), null, 2), "utf8");
-  return PROP_DIR + "/" + file;
+  writeFileSync(join(target, file), JSON.stringify(payload(id, ops, false), null, 2), "utf8");
+  return { auto: [], review: ops, ids: { review: PROP_DIR + "/" + file } };
 }
 
 // Ce texte est lu par CHAQUE acheteur, à chaque création. Il a déjà été faux une
@@ -742,13 +1357,147 @@ function importHint(){
     + "the connector is pointed at a different library — that is why a map can be created and never appear.";
 }
 
+// ---------------------------------------------------------------------------
+// 🃏 Le KANBAN (1.5.0) — lire ses colonnes, et en fabriquer un d'un seul appel
+// ---------------------------------------------------------------------------
+function kanbanToText(doc){
+  const k = doc && doc.kanban;
+  if(!k || !Array.isArray(k.cols) || !k.cols.length) return "";
+  const cols = k.cols.map(c => "“" + c.name + "” (" + c.id + (c.done ? ", done" : "") + (c.wip ? ", WIP " + c.wip : "") + ")").join(" · ");
+  const tags = (k.tags && typeof k.tags === "object") ? Object.entries(k.tags)
+    .filter(([key, v]) => KB_TAG_KEYS.includes(key) && typeof v === "string" && v.trim())
+    .map(([key, v]) => key + " = “" + v.replace(/[\x00-\x1f\x7f]+/g, " ").trim().slice(0, 40) + "”") : [];
+  return "\n\n🃏 Kanban columns: " + cols + (tags.length ? "\n🏷 Labels: " + tags.join(", ") : "")
+    + "\n(Cards are the nodes marked ⟪column: …⟫. Move one with propose_changes op \"move\" and `col` = a column name or id; a ticked card [x] shows in the done column.)";
+}
+function kbTagNames(doc){
+  const t = doc && doc.kanban && doc.kanban.tags;
+  const out = {};
+  if(t && typeof t === "object") for(const k of KB_TAG_KEYS) if(typeof t[k] === "string" && t[k].trim()) out[k] = t[k].trim().slice(0, 40);
+  return out;
+}
+// Une durée en SECONDES, depuis les formes que `parseDur` lit dans l'app (« 2h », « 1h30 », « 45 »
+// = minutes, « 2:15 », « 30m », « 90s »). L'estimation d'un nœud est stockée en secondes (`okSecs`).
+function durSecs(v){
+  const q = String(v == null ? "" : v).trim().toLowerCase().replace(/\s+/g, "");
+  if(!q || !DUR_RE.test(q)) return null;
+  let m;
+  if((m = /^(\d+):([0-5]\d)$/.exec(q))) return (+m[1] * 60 + +m[2]) * 60;
+  if((m = /^(\d+)h(\d+)?m?$/.exec(q))) return (+m[1] * 60 + (+m[2] || 0)) * 60;
+  if((m = /^(\d+)m(in)?$/.exec(q))) return +m[1] * 60;
+  if((m = /^(\d+)s(ec)?$/.exec(q))) return +m[1];
+  return +q * 60;
+}
+const DAY_RE = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
+// Un identifiant sur chaque nœud créé : l'app en donnerait un à l'ouverture, mais la signature du
+// document changerait alors entre le serveur et l'app (un aller-retour de synchro pour rien), et
+// une proposition suivante ne pourrait viser une carte que par son texte.
+function assignIds(n){ if(!n.id) n.id = "n" + Math.random().toString(36).slice(2, 12); (n.children || []).forEach(assignIds); return n; }
+// Les colonnes demandées, validées et munies d'ids — même forme qu'`okKanbanCols` côté app.
+function kanbanColsFrom(list, where){
+  const src = Array.isArray(list) && list.length ? list : [{ name:"To do" }, { name:"Doing" }, { name:"Done", done:true }];
+  if(src.length > 12) throw new Error(where + ": a kanban has 12 columns at most.");
+  const cols = src.map((k, j)=>{
+    const name = String((k && (k.name != null ? k.name : k)) || "").replace(/[\x00-\x1f\x7f]/g, " ").trim().slice(0, 60);
+    if(!name) throw new Error(where + ": column #" + (j+1) + " has no name.");
+    const wip = parseInt(k && k.wip, 10);
+    return Object.assign({ id: "c" + (j+1), name }, k && k.done ? { done: true } : {}, (wip >= 1 && wip <= 99) ? { wip } : {});
+  });
+  if(cols.filter(k => k.done).length > 1) throw new Error(where + ": only one column can be the \"done\" column.");
+  return cols;
+}
+// UN appel, un tableau complet : colonnes, cartes, et sur chaque carte ce que l'app affiche au recto
+// et au dos — responsable, dates, priorité, étiquettes, estimation, levier Ai4X, note, lien,
+// sous-tâches. Tout passe par les mêmes bornes que les propositions : une carte qui serait refusée
+// par l'app à l'ouverture est refusée ICI, en le disant.
+function buildKanbanDoc(args){
+  const name = String(args.name || "").trim() || "Kanban";
+  const cols = kanbanColsFrom(args.columns, "columns");
+  const work = cols.filter(k => !k.done), done = cols.find(k => k.done) || null;
+  const firstWork = (work[0] || cols[0]).id;
+  const colOf = (raw, where)=>{
+    if(raw == null || raw === "") return firstWork;
+    const v = String(raw).trim().toLowerCase();
+    const hit = cols.find(k => k.id === String(raw)) || cols.find(k => k.name.toLowerCase() === v);
+    if(!hit) throw new Error(where + ": no column \"" + raw + "\". Columns: " + cols.map(k => "“" + k.name + "”").join(", ") + ".");
+    return hit.id;
+  };
+  const cards = Array.isArray(args.cards) ? args.cards : [];
+  if(cards.length > 300) throw new Error("A kanban created in one call holds 300 cards at most — create it, then add more with propose_changes.");
+  const root = makeNode(name);
+  root.color = "#dbeafe";
+  cards.forEach((c, i)=>{
+    const where = "card #" + (i+1);
+    const text = String((c && c.text) || "").replace(/[\x00-\x1f\x7f]/g, " ").trim();
+    if(!text) throw new Error(where + ": `text` is required.");
+    const n = makeNode(text.slice(0, 2000));
+    const col = colOf(c.column, where);
+    if(done && col === done.id){ n.col = firstWork; n.check = true; }     // la règle de l'app : Done COCHE, la colonne reste de travail
+    else { n.col = col; n.check = false; }
+    if(c.note != null){ if(typeof c.note !== "string") throw new Error(where + ": `note` must be text."); n.note = c.note.slice(0, 8000); }
+    if(c.link){
+      const l = String(c.link).trim();
+      if(!/^(https?:\/\/[^\s\x00-\x1f]+|mailto:[^\s\x00-\x1f]+|map:[A-Za-z0-9_]+)$/i.test(l)) throw new Error(where + ": `link` must be an https:// or mailto: address, or map:<file>.");
+      n.link = l;
+    }
+    if(c.assign){
+      if(typeof c.assign !== "string" || c.assign.length > 120 || /[\x00-\x1f\x7f]/.test(c.assign)) throw new Error(where + ": `assign` must be a name or e-mail (120 characters max).");
+      n.assign = c.assign.trim();
+    }
+    for(const k of ["start", "due"]) if(c[k]){ if(!DAY_RE.test(String(c[k]))) throw new Error(where + ": `" + k + "` must be YYYY-MM-DD."); n[k] = String(c[k]); }
+    if(n.start && n.due && n.due < n.start){ const t = n.start; n.start = n.due; n.due = t; }   // la règle du fichier : remis en ordre, pas refusé
+    if(c.priority != null && c.priority !== 0){
+      if(!Number.isInteger(c.priority) || c.priority < 1 || c.priority > 6) throw new Error(where + ": `priority` must be 1 (highest) to 6.");
+      n.priority = c.priority;
+    }
+    const tags = c.labels != null ? c.labels : c.tags;
+    if(tags != null){
+      if(!Array.isArray(tags)) throw new Error(where + ": `labels` must be a list of colours.");
+      const bad = tags.filter(t => !KB_TAG_KEYS.includes(t));
+      if(bad.length) throw new Error(where + ": unknown label colour \"" + bad[0] + "\". Use any of: " + KB_TAG_KEYS.join(", ") + ".");
+      if(tags.length) n.tags = KB_TAG_KEYS.filter(k => tags.includes(k));
+    }
+    if(c.est != null && c.est !== ""){
+      const sec = durSecs(c.est);
+      if(sec == null) throw new Error(where + ": `est` must be a duration — \"2h\", \"1h30\", \"45\" (minutes) or \"2:15\".");
+      if(sec > 0) n.est = sec;
+    }
+    if(c.pic){ if(!okPic(String(c.pic))) throw new Error(where + ": `pic` must be \"a:<id>\" (" + ART_IDS_MCP.slice(0, 8).join(", ") + "…) or \"e:<emoji>\"."); n.pic = String(c.pic); }
+    // Les sous-tâches sont des ENFANTS cochables, sans colonne — la règle du dos de la carte
+    // (`kbAddSub`) : jamais des cartes sœurs.
+    const subs = Array.isArray(c.subtasks) ? c.subtasks : [];
+    if(subs.length > 50) throw new Error(where + ": 50 sub-tasks at most.");
+    for(const t of subs){
+      const st = String(t || "").replace(/[\x00-\x1f\x7f]/g, " ").trim();
+      if(!st) continue;
+      const k = makeNode(st.slice(0, 2000)); k.check = false; n.children.push(k);
+    }
+    // Le levier Ai4X : un attribut « Lever: <clé> », exactement ce que pose le dos de la carte.
+    if(c.lever){
+      const lv = String(c.lever).trim().toLowerCase();
+      if(!KB_LEVER_KEYS_MCP.includes(lv)) throw new Error(where + ": `lever` must be one of " + KB_LEVER_KEYS_MCP.join(", ") + ".");
+      n.children.push(makeNode("Lever: " + lv));
+    }
+    root.children.push(n);
+  });
+  assignIds(root);
+  const kanban = { cols };
+  const names = {};
+  if(args.labels && typeof args.labels === "object") for(const k of KB_TAG_KEYS) if(typeof args.labels[k] === "string" && args.labels[k].trim()) names[k] = args.labels[k].replace(/[\x00-\x1f\x7f]/g, " ").trim().slice(0, 40);
+  if(Object.keys(names).length) kanban.tags = names;
+  const doc = { v:1, root, images:[], stickies:[], kanban };
+  const st = okStyleMcp(args.style);
+  if(st) doc.style = st;
+  return doc;
+}
+
 // ---------------------------------------------------------------------------
 // Définition des outils
 // ---------------------------------------------------------------------------
 const TOOLS = [
   {
     name: "list_maps",
-    description: "Lists every mind map and board in the TabTree library (name, type, folder, size, last modified).",
+    description: "Lists every mind map, kanban, note and board in the TabTree library — the user's own and those of the team spaces they belong to (name, type, space, folder, size, last modified).",
     inputSchema: { type:"object", properties:{}, additionalProperties:false }
   },
   {
@@ -763,11 +1512,23 @@ const TOOLS = [
   },
   {
     name: "create_mindmap",
-    description: "Creates a NEW TabTree mind map from a markdown outline (#/## headings, bullet lists indented by 2 spaces, [x]/[ ] checkboxes, [title](url) links, and \" @a:<id>\" / \" @e:<emoji>\" at the end of a line for an illustration). The first top-level line becomes the centre. Writes a .tabtree file into the backup folder; the user pulls it into the app from the 🛟 menu.",
+    description: "Creates a NEW TabTree mind map from a markdown outline (#/## headings, bullet lists indented by 2 spaces, [x]/[ ] checkboxes, [title](url) links, and \" @a:<id>\" / \" @e:<emoji>\" at the end of a line for an illustration). The first top-level line becomes the centre. SCREENSHOTS: pass `images` — a list of { target, file } where `file` is the path of a PNG/JPEG on this machine (a screenshot you saved) and `target` the exact text of the node it goes on; the picture is re-encoded to fit and drawn as the node's cover. Writes a .tabtree file into the backup folder; the user pulls it into the app from the 🛟 menu.",
     inputSchema: { type:"object", properties:{
       name:{ type:"string", description:"Name of the map" },
       markdown:{ type:"string", description:"Markdown outline (headings and/or bullet list). End any line with \" @a:<id>\" to give that node a built-in illustration, or \" @e:<emoji>\" for one large emoji — e.g. \"Launch @a:rocket\". Ids: person, team, chat, idea, target, trophy, star, heart, warning, done, flag, clock, laptop, phone, mail, folder, book, chart, money, calendar, building, car, globe, rocket, house, pin, plane, coffee, plant, sun, camera, music, lock, key, health, gift. An unknown id is left as plain text rather than dropped." },
-      folder:{ type:"string", description:"Optional TabTree subfolder (e.g. \"From Claude\")" },
+      folder:{ type:"string", description:"Optional TabTree folder. A NAME (\"From Claude\") or a full PATH (\"Ai4X / Programmes\"). When several folders share a name, the shallowest is used and the answer says which — pass the full path to choose another." },
+      space:{ type:"string", description:"Optional TabTree SPACE to put it in, by name — one of the user's spaces, or a TEAM space they are an editor of (every member then sees it). list_maps shows the spaces. Omit for the user's own library." },
+      view:{ type:"string", enum:["map","note","gantt"], description:"How TabTree opens it: map (default, a mind map), note (a page of text — the outline becomes headings and paragraphs, for meeting notes or a document), gantt (a timeline — give `dates`). It stays one document: the user can switch views at any time." },
+      dates:{ type:"array", description:"Optional start/due days on nodes — what the Gantt view draws (and what the kanban and calendar show). One entry per node.", items:{ type:"object", properties:{
+        target:{ type:"string", description:"Exact node text, or \"Ancestor > Node\"" },
+        start:{ type:"string", description:"YYYY-MM-DD" },
+        due:{ type:"string", description:"YYYY-MM-DD" }
+      }, required:["target"], additionalProperties:false } },
+      images:{ type:"array", description:"Optional screenshots, one per node: { target, file } or { target, data }. `target` = the exact text of a line of the outline (or \"Ancestor > Node\" when the wording repeats); `file` = full path of a PNG/JPEG/WebP/GIF on this machine (take the screenshot, save it, pass the path); `data` = a data:image/… URL instead of a file. The image is re-encoded to about 840 px and becomes the node's cover picture (it replaces any @a:/@e: illustration on that node). 60 max.", items:{ type:"object", properties:{
+        target:{ type:"string", description:"Exact node text, or \"Ancestor > Node\"" },
+        file:{ type:"string", description:"Path of the image file on this machine" },
+        data:{ type:"string", description:"A data:image/(png|jpeg|webp|gif);base64,… URL — instead of `file`" }
+      }, required:["target"], additionalProperties:false } },
       style:{ type:"object", description:"Optional look of the document. Omit it for the default.", properties:{
         font:{ type:"string", enum:["","grotesk","humanist","condensed","rounded","serif","garamond","didone","slab","typewriter","mono","hand"], description:"Type family: grotesk (corporate), humanist (warm), condensed (dense), rounded (friendly), serif/garamond (editorial), didone (elegant), slab (sturdy), typewriter, mono (technical), hand (handwritten)." },
         shape:{ type:"string", enum:["","line","plain"], description:"Node shape: cards (default), line = underlined, plain = plain text." },
@@ -799,7 +1560,8 @@ const TOOLS = [
       connections:{ type:"array", description:"Arrows anchored between elements (by id)", items:{ type:"object", properties:{
         from:{ type:"string" }, to:{ type:"string" }
       }, required:["from","to"], additionalProperties:false } },
-      folder:{ type:"string", description:"Optional TabTree subfolder" },
+      folder:{ type:"string", description:"Optional TabTree folder. A NAME or a full PATH (\"Ai4X / Programmes\"). When several folders share a name, the shallowest is used and the answer says which." },
+      space:{ type:"string", description:"Optional TabTree SPACE to put it in, by name — one of the user's spaces, or a TEAM space they are an editor of (every member then sees it). list_maps shows the spaces. Omit for the user's own library." },
       style:{ type:"object", description:"Optional look of the document. Omit it for the default.", properties:{
         font:{ type:"string", enum:["","grotesk","humanist","condensed","rounded","serif","garamond","didone","slab","typewriter","mono","hand"], description:"Type family: grotesk (corporate), humanist (warm), condensed (dense), rounded (friendly), serif/garamond (editorial), didone (elegant), slab (sturdy), typewriter, mono (technical), hand (handwritten)." },
         shape:{ type:"string", enum:["","line","plain"], description:"Node shape: cards (default), line = underlined, plain = plain text." },
@@ -811,22 +1573,68 @@ const TOOLS = [
       }, additionalProperties:false }
     }, required:["name","elements"], additionalProperties:false }
   },
+  {
+    name: "create_kanban",
+    description: "Creates a NEW TabTree kanban board in one call — columns and cards, each card with what TabTree shows on it: owner, start/due days, priority, colour labels, time estimate, Ai4X lever, note (links in it become clickable — a Google Meet link, a doc), a link, and sub-tasks. It opens directly as a kanban in TabTree, on every device signed in to the account, and in a TEAM space every member sees it. To add or move cards on an EXISTING kanban, use propose_changes instead.",
+    inputSchema: { type:"object", properties:{
+      name:{ type:"string", description:"Name of the board (e.g. \"Sprint W43\", \"Launch\")" },
+      columns:{ type:"array", description:"The columns, left to right. Omit for To do / Doing / Done. Mark ONE column done:true: a card put there is ticked, and unticking it sends it back. 12 max.", items:{ type:"object", properties:{
+        name:{ type:"string" }, done:{ type:"boolean" }, wip:{ type:"integer", description:"Optional work-in-progress limit 1–99 (the column turns red above it — nothing is blocked)" }
+      }, required:["name"], additionalProperties:false } },
+      cards:{ type:"array", description:"The cards, in order within each column. 300 max.", items:{ type:"object", properties:{
+        text:{ type:"string", description:"The card's title" },
+        column:{ type:"string", description:"Column NAME (or id). Default: the first column" },
+        assign:{ type:"string", description:"Owner — a name or e-mail" },
+        start:{ type:"string", description:"YYYY-MM-DD" },
+        due:{ type:"string", description:"YYYY-MM-DD" },
+        priority:{ type:"integer", description:"1 (highest) to 6" },
+        labels:{ type:"array", items:{ type:"string" }, description:"Colour labels from: green, yellow, orange, red, purple, blue, sky, lime, pink, gray (name them with `labels` at the board level)" },
+        est:{ type:"string", description:"Time estimate: \"2h\", \"1h30\", \"45\" (minutes), \"2:15\"" },
+        lever:{ type:"string", enum:["human","think","accelerate","automate"], description:"Ai4X lever: human (stays human), think (think with Claude), accelerate (Claude Code or a connector), automate (a skill or a scheduled task)" },
+        note:{ type:"string", description:"The back of the card — plain text; http(s) and mailto links become clickable" },
+        link:{ type:"string", description:"An https:// or mailto: link on the card, or map:<file> to open another map from list_maps" },
+        subtasks:{ type:"array", items:{ type:"string" }, description:"Sub-tasks, ticked on the back of the card (the card shows n/m)" },
+        pic:{ type:"string", description:"\"a:<id>\" built-in illustration or \"e:<emoji>\"" }
+      }, required:["text"], additionalProperties:false } },
+      labels:{ type:"object", description:"Optional names for the colour labels, e.g. { \"red\": \"Bug\", \"green\": \"Quick win\" }", additionalProperties:{ type:"string" } },
+      folder:{ type:"string", description:"Optional folder, by NAME or full PATH." },
+      space:{ type:"string", description:"Optional TabTree SPACE to put it in, by name — one of the user's spaces, or a TEAM space they are an editor of (every member then sees it). list_maps shows the spaces. Omit for the user's own library." },
+      style:{ type:"object", description:"Optional look (same keys as create_mindmap: font, background, skin…).", additionalProperties:true }
+    }, required:["name"], additionalProperties:false }
+  },
   {
     name: "propose_changes",
-    description: "Proposes changes to an EXISTING mind map: add branches, rename a node, write a note, tick a task, remove a branch, illustrate a node — or, with op \"persona\", re-cast a WORK MAP canvas from a finished interview (the JSON block of the « ma cartographie du travail » skill). Nothing is applied — the proposal appears in TabTree as a banner on that map, the user reviews it change by change and picks what to keep (and can undo with Cmd+Z afterwards). Name each target node by its exact text, or by a path \"Ancestor > Node\" when the same wording appears twice. Read the map first so the wording matches.",
+    description: "Changes an EXISTING mind map or kanban (also one in a team space). HYBRID, by design: SAFE changes — add cards or branches, move a card to a column, tick it, set its owner, dates, priority, labels, estimate, Ai4X lever, an attribute, a link, a comment, a picture, and set up the columns of a board that has none — are APPLIED BY TABTREE ITSELF within seconds when TabTree is open on one of the user's devices (otherwise the next time it opens), and Cmd+Z undoes them. Changes that rewrite or remove what someone wrote — rename, note, delete, replacing existing columns, a persona re-cast — appear as a banner for the user to review and approve. In one call, the safe changes BEFORE the first review-only change apply by themselves and the rest goes to review, in order. Name each target node by its exact text, or by a path \"Ancestor > Node\" when the same wording appears twice; a later change may target a node added earlier in the same call. Read the map first so the wording matches.",
     inputSchema: { type:"object", properties:{
       file:{ type:"string", description:"The map to change — a file name (or map name) from list_maps" },
       note:{ type:"string", description:"One line telling the user what this proposal does and why. Shown above the changes." },
       changes:{ type:"array", description:"The proposed changes, applied in order", items:{ type:"object", properties:{
-        op:{ type:"string", enum:["add","rename","note","check","delete","move","pic","persona"], description:"add = new children under `target`; rename = change its text; note = set its note; check = tick/untick the task; delete = remove it and its children; move = send the card to a kanban column; pic = put an illustration on it; persona = re-cast a work map canvas (a board whose name starts with “Work map —” / “Cartographie —”) from an interview — no target" },
+        op:{ type:"string", enum:["add","rename","note","check","delete","move","pic","img","persona","tags","assign","priority","due","start","attr","comment","est","lever","link","columns"], description:"columns = set the kanban columns (give `columns`; no target) — on a map with no kanban yet this creates the board; add = new children under `target`; rename = change its text; note = set its note; check = tick/untick the task; delete = remove it and its children; move = send the card to a kanban column; pic = put an illustration on it; img = put a SCREENSHOT on it (give `file`, the path of the image on this machine — or `data`; `img: \"\"` removes it); persona = re-cast a work map canvas (a board whose name starts with “Work map —” / “Cartographie —”) or a Second Brain Blueprint (“Second brain —”) from an interview — no target; tags = set the card's colour labels; assign = who the task is for; priority = 1 (highest) to 6; due = the due day; attr = set a “Name: value” attribute on the node (an estimate, a budget…); comment = add a signed comment to the card's thread (give `text`); est = set the time ESTIMATE of the task (give `est`, e.g. \"2h\", \"45\" = 45 minutes, \"\" removes it); start = the start day; lever = the card's Ai4X lever (give `lever`); link = put a link on the node (give `link`)" },
         target:{ type:"string", description:"Exact node text, or \"Ancestor > Node\" if ambiguous (not used by persona)" },
         persona:{ type:"object", description:"persona: the interview object exactly as the skill returns it — who, role, mission, tools, meetings, opener, modules[{name, procs[{name,h,after,freq,rep,data,stakes,lever,step,why}]}], trajectory, signs, parking. TabTree rebuilds the canvas AND its companion sheet from it." },
         markdown:{ type:"string", description:"add: the new branch as a bullet list, 2 spaces per level" },
-        text:{ type:"string", description:"rename: the new text" },
+        text:{ type:"string", description:"rename: the new text. comment: the comment body (plain text; http/mailto links become clickable)" },
         note:{ type:"string", description:"note: the note body (empty string clears it)" },
-        value:{ type:"boolean", description:"check: true to tick, false to untick" },
-        col:{ type:"string", description:"move: the kanban column id (read_map shows them), or \"\" to take the card off the board" },
-        pic:{ type:"string", description:"pic: \"a:<id>\" for a built-in illustration, or \"e:<emoji>\" for one large emoji, or \"\" to remove it. Ids: person, team, chat, idea, target, trophy, star, heart, warning, done, flag, clock, laptop, phone, mail, folder, book, chart, money, calendar, building, car, globe, rocket, house, pin, plane, coffee, plant, sun, camera, music, lock, key, health, gift." }
+        col:{ type:"string", description:"move: the kanban column — its NAME (\"Doing\") or id, both shown by read_map — or \"\" to take the card off the board. add: optional — the column the NEW cards go to" },
+        columns:{ type:"array", description:"columns: the board's columns left to right — [{ name, done?, wip? }]; mark ONE done:true. Existing columns keep their cards when their name is kept", items:{ type:"object", properties:{ name:{ type:"string" }, done:{ type:"boolean" }, wip:{ type:"integer" } }, required:["name"], additionalProperties:false } },
+        start:{ type:"string", description:"start: the start day as YYYY-MM-DD (\"\" removes it)" },
+        lever:{ type:"string", description:"lever: human, think, accelerate or automate (\"\" removes it)" },
+        link:{ type:"string", description:"link: an https:// or mailto: address, or map:<file> to open another map (\"\" removes it)" },
+        pic:{ type:"string", description:"pic: \"a:<id>\" for a built-in illustration, or \"e:<emoji>\" for one large emoji, or \"\" to remove it. Ids: person, team, chat, idea, target, trophy, star, heart, warning, done, flag, clock, laptop, phone, mail, folder, book, chart, money, calendar, building, car, globe, rocket, house, pin, plane, coffee, plant, sun, camera, music, lock, key, health, gift." },
+        file:{ type:"string", description:"img: full path of the screenshot (PNG/JPEG/WebP/GIF) on this machine. It is re-encoded to about 840 px and becomes the node's cover picture." },
+        data:{ type:"string", description:"img: a data:image/…;base64 URL instead of `file`" },
+        img:{ type:"string", description:"img: pass \"\" to REMOVE the screenshot from that node (otherwise give `file` or `data`)" },
+        tags:{ type:"array", items:{ type:"string" }, description:"tags: the colour labels to set, from: green, yellow, orange, red, purple, blue, sky, lime, pink, gray — read_map shows the name the board gave each colour. [] clears them." },
+        assign:{ type:"string", description:"assign: a name or e-mail (\"\" clears it). add: optional — the owner of the NEW cards. When read_map shows a 👥 Team, pick from it, by role, what each person owns and their objectives" },
+        why:{ type:"string", description:"Any change: optional — one short line saying WHY (e.g. \"Owns the website\"). Shown to the user next to the change, so they can judge it" },
+        priority:{ type:"integer", description:"priority: 1 (highest) to 6, or 0 to remove it" },
+        due:{ type:"string", description:"due: the due day as YYYY-MM-DD (\"\" removes it)" },
+        name:{ type:"string", description:"attr: the attribute's name, e.g. \"Estimate\"" },
+        // ⚠️ UNE seule déclaration de `value` (1.5.0) : il y en avait deux (booléen pour check, texte pour
+        // attr) et la seconde écrasait la première — le schéma disait donc « texte » pour un check, et
+        // Claude envoyait "true", que le contrôle d'un check refuse.
+        value:{ type:["boolean","string"], description:"check: true to tick, false to untick. attr: its value as text, e.g. \"2h\" (\"\" removes the attribute)" },
+        est:{ type:"string", description:"est: the estimate as a duration — \"2h\", \"1h30\", \"45\" (minutes), \"2:15\" — or \"\" to remove it" }
       }, required:["op"], additionalProperties:false } }
     }, required:["file","changes"], additionalProperties:false }
   }
@@ -836,18 +1644,35 @@ const HANDLERS = {
   async list_maps(){
     const maps = await loadLibrary();
     if(!maps.length) return CLOUD ? "This TabTree account has no maps yet." : "The library is empty (or TABTREE_DIR points at the wrong folder: " + DIR + ").";
-    return maps.map(m=>
-      `• ${m.name}  [${m.kind}]${m.folder ? "  📁 " + m.folder : ""}\n  file: ${m.file}\n  ${m.kind==="board" ? m.elements + " elements" : m.nodes + " nodes"} · modified ${m.mtime}`
-    ).join("\n");
+    const lines = maps.map(m=>
+      `• ${m.name}  [${m.kind}]${m.space ? "  " + (m.team ? "👥 " : "◻︎ ") + m.space + (m.team ? " (" + m.role + ")" : "") : ""}${m.folder ? "  📁 " + m.folder : ""}${m.tabOf ? "  ↳ tab of “" + m.tabOf + "”" : ""}\n  file: ${m.file}\n  ${m.kind==="board" ? m.elements + " elements" : m.nodes + " nodes"} · modified ${m.mtime}`
+    );
+    // Les espaces où Claude peut créer (`space` des outils de création) — y compris ceux qui sont VIDES,
+    // qu'aucune carte ne ferait apparaître dans la liste.
+    const sps = CLOUD && cloudSpacesCache && cloudSpacesCache.length
+      ? "\n\nSpaces: " + cloudSpacesCache.map(x=>"“" + x.name + "”" + (x.role !== "owner" ? " (team, " + x.role + (x.writable ? "" : ", read-only") + ")" : "")).join(", ")
+      : "";
+    return lines.join("\n") + sps;
   },
   async read_map(args){
-    const m = await findMap(args.file);
-    const head = `${m.name} [${m.kind}] — file: ${m.file}\n`;
+    checkRelPath(args.file);
+    const all = await loadLibrary();
+    const m = all.find(x=>x.file===args.file) || all.find(x=>x.file.endsWith(args.file)) || all.find(x=>x.name===args.file);
+    if(!m) throw new Error("No such map: " + args.file + ". Use list_maps to see what is available.");
+    const head = `${m.name} [${m.kind}]${m.space ? " — space “" + m.space + "”" + (m.team ? " (team, " + m.role + ")" : "") : ""} — file: ${m.file}\n`;
     if(m.kind === "board") return head + boardToText(m.doc);
+    // Les cartes qu'un lien `map:` peut ouvrir, par l'id que l'app leur donne (clé, ou id d'équipe).
+    const maps = new Map();
+    for(const x of all){ maps.set(x.file, { name: x.name, kind: x.kind }); if(x.key) maps.set(x.key, { name: x.name, kind: x.kind }); }
+    const ctx = { cols: (m.doc.kanban && Array.isArray(m.doc.kanban.cols)) ? m.doc.kanban.cols : [], tagNames: kbTagNames(m.doc), maps };
     // Le rappel sur propose_changes vit ici et pas dans la description de l'outil : c'est au
     // moment où le plan est sous les yeux qu'il est utile, et il porte la règle de désignation.
-    return head + nodeToMarkdown(m.doc.root, 0)
-      + "\n\n(To change this map, use propose_changes with `file: \"" + m.file + "\"`. Name a node by the exact text above, or \"Ancestor > Node\" when it appears twice. Nothing is applied until the user approves it in TabTree.)";
+    const ro = m.team && m.role === "viewer";
+    return head + nodeToMarkdown(m.doc.root, 0, ctx) + kanbanToText(m.doc) + teamToText(m.doc)
+      + (ro ? "\n\n(You can read this team map but not change it — the user's role in its space is viewer.)"
+            : "\n\n(To change this map, use propose_changes with `file: \"" + m.file + "\"`. Name a node by the exact text above, or \"Ancestor > Node\" when it appears twice. "
+              + (CLOUD ? "Safe changes (add, move, tick, owner, dates, labels, lever…) are applied by TabTree itself; rename, note and delete wait for the user's approval.)"
+                       : "Nothing is applied until the user approves it in TabTree.)"));
   },
   async search_maps(args){
     const q = String(args.query||"").toLowerCase();
@@ -879,15 +1704,39 @@ const HANDLERS = {
     // comparé caractère par caractère avec celui de l'app, et lui ajouter une syntaxe le ferait
     // diverger en silence. Même partage des rôles que côté modèles.
     tplPicAssign(root);
+    // Les captures d'écran APRÈS les marqueurs : une désignation se retire du texte avant que le
+    // texte serve de cible, et une capture remplace l'illustration du même nœud.
+    const shots = applyImages(root, args.images);
+    // Les DATES (1.5.0) : ce que la vue Gantt dessine. Une cible introuvable ou ambiguë est refusée
+    // en le disant — une date posée sur le mauvais nœud fausserait toute la frise.
+    const dated = [];
+    if(args.dates != null){
+      if(!Array.isArray(args.dates)) throw new Error("`dates` must be a list of { target, start, due }.");
+      args.dates.forEach((d, i)=>{
+        const where = "dates #" + (i+1);
+        const r = propFind(root, String((d && d.target) || ""));
+        if(r.error === "empty") throw new Error(where + ": `target` is required.");
+        if(r.error === "missing") throw new Error(where + ": no node \"" + d.target + "\" in this outline.");
+        if(r.error === "ambiguous") throw new Error(where + ": \"" + d.target + "\" matches " + r.count + " nodes — use \"Ancestor > Node\".");
+        for(const k of ["start", "due"]) if(d[k]){ if(!DAY_RE.test(String(d[k]))) throw new Error(where + ": `" + k + "` must be YYYY-MM-DD."); r.node[k] = String(d[k]); }
+        if(r.node.start && r.node.due && r.node.due < r.node.start){ const t = r.node.start; r.node.start = r.node.due; r.node.due = t; }
+        dated.push(r.node);
+      });
+    }
+    const view = ["note", "gantt"].includes(args.view) ? args.view : "map";
+    if(view === "gantt" && !dated.length) throw new Error("A Gantt needs dates — pass `dates` with a start and/or due day for the nodes to draw.");
+    assignIds(root);
     const doc = { v:1, root, images:[], stickies:[] };
     const st = okStyleMcp(args.style);
     if(st) doc.style = st;
-    const file = await writeDoc(args.name || root.text, doc, args.folder);
-    return `✅ Map created (${countNodes(root)} nodes): ${file}\n${importHint()}`;
+    const file = await writeDoc(args.name || root.text, doc, args.folder, { kind: view, space: args.space });
+    const shotLines = shots.length ? `\n📷 ${shots.length} screenshot(s) on the map:\n` + shots.map(x=>"   • " + x).join("\n") + "\n" : "";
+    const label = view === "note" ? "Note" : view === "gantt" ? "Gantt" : "Map";
+    return `✅ ${label} created (${countNodes(root)} nodes${dated.length ? ", " + dated.length + " dated" : ""}): ${file}\n${shotLines}${importHint()}`;
   },
   async create_board(args){
     const { doc, warnings } = buildBoardDoc(args.name || "Board", args.elements, args.connections, args.style);
-    const file = await writeDoc(args.name || "Board", doc, args.folder);
+    const file = await writeDoc(args.name || "Board", doc, args.folder, { space: args.space });
     const n = doc.shapes.length + doc.stickies.length;
     // Les avertissements passent AVANT l'astuce d'import : c'est le seul moment où le texte
     // peut encore être raccourci, et une ligne noyée en fin de réponse ne se lit pas.
@@ -899,6 +1748,15 @@ const HANDLERS = {
       : "";
     return `✅ Board created (${n} elements, ${doc.arrows.length} connection(s)): ${file}\n${warn}${importHint()}`;
   },
+  async create_kanban(args){
+    if(typeof args.name !== "string" || !args.name.trim()) throw new Error("The `name` parameter is required (the board's name).");
+    const doc = buildKanbanDoc(args);
+    const file = await writeDoc(args.name, doc, args.folder, { kind: "kanban", space: args.space });
+    const cards = doc.root.children;
+    const per = doc.kanban.cols.map(k => k.name + " " + cards.filter(c => k.done ? c.check === true : (c.col === k.id && c.check !== true)).length).join(" · ");
+    return `✅ Kanban created — ${cards.length} card(s): ${per}\n${file}\n${importHint()}`
+      + (CLOUD ? "\nIt opens as a kanban. To add or move cards later, use propose_changes on this file — those changes apply by themselves." : "");
+  },
   async propose_changes(args){
     const m = await findMap(args.file);
     // Un persona est la SEULE op qui vise un board — la work map en est un — et il ne vise que ça.
@@ -906,26 +1764,36 @@ const HANDLERS = {
     if(m.kind === "board" && !allPersona)
       throw new Error("Proposals only apply to mind maps. A board has free positions and drawings, which a change list cannot describe.");
     if(allPersona && m.kind !== "board")
-      throw new Error("A persona re-casts a WORK MAP canvas, which is a board. “" + m.name + "” is a mind map — pick the person's work map from list_maps (its name starts with “Work map —” or “Cartographie —”).");
+      throw new Error("A persona re-casts a WORK MAP or a SECOND BRAIN BLUEPRINT canvas, which is a board. “" + m.name + "” is a mind map — pick the person's canvas from list_maps (its name starts with “Work map —”, “Cartographie —” or “Second brain —”).");
+    if(m.team && m.role === "viewer") throw new Error("“" + m.name + "” is in a team space where the user is a viewer — it can be read, not changed. Ask the space's owner for the editor role.");
     const ops = buildProposalOps(m.doc, args.changes);
-    const file = await writeProposal(m, args.note, ops);
+    const res = await writeProposal(m, args.note, ops, { review: allPersona });
     if(allPersona){
-      return `📮 Interview filed for “${m.name}” — ${ops[0].procs} processes: ${file}\n`
+      return `📮 Interview filed for “${m.name}” — ${ops[0].domains ? ops[0].domains + " domains" : ops[0].procs + " processes"}: ${res.ids.review}\n`
         + "NOTHING has been changed yet. The canvas file is untouched.\n"
         + (CLOUD ? "TabTree shows a banner on that work map within a minute (app open, signed in): " : "TabTree shows a banner on that work map within a few seconds (backup folder connected, app open): ") + "“Your Claude interview is ready — re-cast this work map?”. "
         + "One click rebuilds the canvas AND its companion sheet from these hours; Cmd+Z undoes it.\n"
         + "Tell the user to look at TabTree — do not claim the map has been re-cast.";
     }
-    const adds = ops.reduce((n,o)=>n + (o.adds||0), 0);
-    const drops = ops.reduce((n,o)=>n + (o.drops||0), 0);
-    return `📮 Proposal filed for “${m.name}” — ${ops.length} change(s)`
-      + (adds ? `, ${adds} node(s) to add` : "")
-      + (drops ? `, ${drops} node(s) to remove` : "")
-      + `: ${file}\n`
-      + "NOTHING has been changed yet. The map file is untouched.\n"
-      + (CLOUD ? "TabTree shows a banner on that map within a minute (the app open and signed in). " : "TabTree shows a banner on that map within a few seconds (the backup folder must be connected, and the app open). ")
-      + "The user ticks the changes they want, applies them, and Cmd+Z undoes the lot.\n"
-      + "Tell the user to look at TabTree — do not claim the map has been updated.";
+    const tally = (list)=>{
+      const adds = list.reduce((n,o)=>n + (o.adds||0), 0), drops = list.reduce((n,o)=>n + (o.drops||0), 0);
+      const shots = list.filter(o=>o.op === "img" && o.img).length;
+      return list.length + " change(s)" + (adds ? `, ${adds} node(s) to add` : "") + (drops ? `, ${drops} node(s) to remove` : "") + (shots ? `, ${shots} screenshot(s)` : "");
+    };
+    const shotLines = ops.filter(o=>o.op === "img" && o.img).map(o=>"   📷 “" + String(o.was || o.target).slice(0, 60) + "” ← " + o.shot).join("\n");
+    let out = "";
+    if(res.auto.length){
+      out += `⚡ ${tally(res.auto)} sent to “${m.name}” — TabTree applies them BY ITSELF within seconds when it is open on one of the user's devices (signed in), otherwise the next time it opens. `
+        + "Cmd+Z undoes them. They have not been applied yet at this instant: do not read the map back expecting them — tell the user they are on their way.\n";
+    }
+    if(res.review.length){
+      out += `📮 Proposal filed for “${m.name}” — ${tally(res.review)}${res.auto.length ? " (everything from the first change that rewrites or removes something)" : ""}: ${CLOUD ? "cloud:" + res.ids.review : res.ids.review}\n`
+        + "NOTHING has been changed yet by these. The map is untouched until the user approves them.\n"
+        + (CLOUD ? "TabTree shows a banner on that map within a minute (the app open and signed in). " : "TabTree shows a banner on that map within a few seconds (the backup folder must be connected, and the app open). ")
+        + "The user ticks the changes they want, applies them, and Cmd+Z undoes the lot.\n"
+        + "Tell the user to look at TabTree — do not claim those changes are made.\n";
+    }
+    return out + (shotLines ? shotLines + "\n" : "");
   }
 };
 
@@ -947,7 +1815,7 @@ function handle(msg){
       // déjà dérivé (1.0.0 ici, 1.1.0 dans le manifeste) sans que rien ne le
       // signale : un client affiche l'une, le registre publie l'autre. Un
       // autotest les compare désormais toutes les quatre.
-      serverInfo: { name: "tabtree", version: "1.2.1" }
+      serverInfo: { name: "tabtree", version: "1.5.0" }
     });
   } else if(method === "notifications/initialized" || (method||"").startsWith("notifications/")){
     // notification : pas de réponse