Jauge de contexte, espace disque sur partage agrégé, panneau Fichiers

Trois défauts sans rapport entre eux, tous visibles à l'écran.

Jauge de contexte bloquée à « 0 / N (0 %) » : le comptage exact vient de
usage.prompt_tokens (include_usage), qu'un llama-server récent a cessé de
renvoyer. On note désormais si l'usage est arrivé ; sinon la fin de tour
publie l'estimation qui pilote déjà la compaction — approximative, mais
jamais absente. Et la souscription envoie la valeur courante juste après
le rattrapage : une page rechargée affichait zéro sur une discussion
pourtant pleine, faute d'événement ctx_used dans la fenêtre rejouée.

Espace disque : « il ne reste que 11,9 Go » sur un partage Unraid qui en
a des centaines. /mnt/user est servi par shfs, un FUSE qui agrège
plusieurs disques — statfs y renvoie l'espace d'un seul, et ce chiffre
REFUSAIT l'installation du modèle. Les systèmes de fichiers qui
approximent (FUSE, overlay, NFS, CIFS, Ceph, Gluster) sont reconnus par
leur magie : leur chiffre reste affiché, précédé d'un « ~ », mais ne
bloque plus rien.

Panneau Fichiers : le panneau entier défilait, emportant vers le haut
l'en-tête, le fil d'Ariane et le pied (occupation disque, bouton .zip)
dès qu'il y avait quelques fichiers. Seule la liste défile maintenant ;
le pied reste en bas et l'état vide se centre.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

frontend/node_modules/@babel/template/lib/populate.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = populatePlaceholders;
+var _t = require("@babel/types");
+const {
+  blockStatement,
+  cloneNode,
+  emptyStatement,
+  expressionStatement,
+  identifier,
+  isStatement,
+  isStringLiteral,
+  stringLiteral,
+  validate
+} = _t;
+function populatePlaceholders(metadata, replacements) {
+  const ast = cloneNode(metadata.ast);
+  if (replacements) {
+    metadata.placeholders.forEach(placeholder => {
+      if (!hasOwnProperty.call(replacements, placeholder.name)) {
+        const placeholderName = placeholder.name;
+        throw new Error(`Error: No substitution given for "${placeholderName}". If this is not meant to be a
+            placeholder you may want to consider passing one of the following options to @babel/template:
+            - { placeholderPattern: false, placeholderWhitelist: new Set(['${placeholderName}'])}
+            - { placeholderPattern: /^${placeholderName}$/ }`);
+      }
+    });
+    Object.keys(replacements).forEach(key => {
+      if (!metadata.placeholderNames.has(key)) {
+        throw new Error(`Unknown substitution "${key}" given`);
+      }
+    });
+  }
+  metadata.placeholders.slice().reverse().forEach(placeholder => {
+    try {
+      var _ref;
+      applyReplacement(placeholder, ast, (_ref = replacements && replacements[placeholder.name]) != null ? _ref : null);
+    } catch (e) {
+      e.message = `@babel/template placeholder "${placeholder.name}": ${e.message}`;
+      throw e;
+    }
+  });
+  return ast;
+}
+function applyReplacement(placeholder, ast, replacement) {
+  if (placeholder.isDuplicate) {
+    if (Array.isArray(replacement)) {
+      replacement = replacement.map(node => cloneNode(node));
+    } else if (typeof replacement === "object") {
+      replacement = cloneNode(replacement);
+    }
+  }
+  const {
+    parent,
+    key,
+    index
+  } = placeholder.resolve(ast);
+  if (placeholder.type === "string") {
+    if (typeof replacement === "string") {
+      replacement = stringLiteral(replacement);
+    }
+    if (!replacement || !isStringLiteral(replacement)) {
+      throw new Error("Expected string substitution");
+    }
+  } else if (placeholder.type === "statement") {
+    if (index === undefined) {
+      if (!replacement) {
+        replacement = emptyStatement();
+      } else if (Array.isArray(replacement)) {
+        replacement = blockStatement(replacement);
+      } else if (typeof replacement === "string") {
+        replacement = expressionStatement(identifier(replacement));
+      } else if (!isStatement(replacement)) {
+        replacement = expressionStatement(replacement);
+      }
+    } else {
+      if (replacement && !Array.isArray(replacement)) {
+        if (typeof replacement === "string") {
+          replacement = identifier(replacement);
+        }
+        if (!isStatement(replacement)) {
+          replacement = expressionStatement(replacement);
+        }
+      }
+    }
+  } else if (placeholder.type === "param") {
+    if (typeof replacement === "string") {
+      replacement = identifier(replacement);
+    }
+    if (index === undefined) throw new Error("Assertion failure.");
+  } else {
+    if (typeof replacement === "string") {
+      replacement = identifier(replacement);
+    }
+    if (Array.isArray(replacement)) {
+      throw new Error("Cannot replace single expression with an array.");
+    }
+  }
+  function set(parent, key, value) {
+    const node = parent[key];
+    parent[key] = value;
+    if (node.type === "Identifier" || node.type === "Placeholder") {
+      if (node.typeAnnotation) {
+        value.typeAnnotation = node.typeAnnotation;
+      }
+      if (node.optional) {
+        value.optional = node.optional;
+      }
+      if (node.decorators) {
+        value.decorators = node.decorators;
+      }
+    }
+  }
+  if (index === undefined) {
+    validate(parent, key, replacement);
+    set(parent, key, replacement);
+  } else {
+    const items = parent[key].slice();
+    if (placeholder.type === "statement" || placeholder.type === "param") {
+      if (replacement == null) {
+        items.splice(index, 1);
+      } else if (Array.isArray(replacement)) {
+        items.splice(index, 1, ...replacement);
+      } else {
+        set(items, index, replacement);
+      }
+    } else {
+      set(items, index, replacement);
+    }
+    validate(parent, key, items);
+    parent[key] = items;
+  }
+}
+
+//# sourceMappingURL=populate.js.map