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/postcss/lib/processor.d.ts

@@ -0,0 +1,114 @@
+import Document from './document.js'
+import LazyResult from './lazy-result.js'
+import NoWorkResult from './no-work-result.js'
+import {
+  AcceptedPlugin,
+  Plugin,
+  ProcessOptions,
+  TransformCallback,
+  Transformer
+} from './postcss.js'
+import Result from './result.js'
+import Root from './root.js'
+
+declare namespace Processor {
+  export { Processor_ as default }
+}
+
+/**
+ * Contains plugins to process CSS. Create one `Processor` instance,
+ * initialize its plugins, and then use that instance on numerous CSS files.
+ *
+ * ```js
+ * const processor = postcss([autoprefixer, postcssNested])
+ * processor.process(css1).then(result => console.log(result.css))
+ * processor.process(css2).then(result => console.log(result.css))
+ * ```
+ */
+declare class Processor_ {
+  /**
+   * Plugins added to this processor.
+   *
+   * ```js
+   * const processor = postcss([autoprefixer, postcssNested])
+   * processor.plugins.length //=> 2
+   * ```
+   */
+  plugins: (Plugin | TransformCallback | Transformer)[]
+
+  /**
+   * Current PostCSS version.
+   *
+   * ```js
+   * if (result.processor.version.split('.')[0] !== '6') {
+   *   throw new Error('This plugin works only with PostCSS 6')
+   * }
+   * ```
+   */
+  version: string
+
+  /**
+   * @param plugins PostCSS plugins
+   */
+  constructor(plugins?: readonly AcceptedPlugin[])
+
+  /**
+   * Parses source CSS and returns a `LazyResult` Promise proxy.
+   * Because some plugins can be asynchronous it doesn’t make
+   * any transformations. Transformations will be applied
+   * in the `LazyResult` methods.
+   *
+   * ```js
+   * processor.process(css, { from: 'a.css', to: 'a.out.css' })
+   *   .then(result => {
+   *      console.log(result.css)
+   *   })
+   * ```
+   *
+   * @param css String with input CSS or any object with a `toString()` method,
+   *            like a Buffer. Optionally, send a `Result` instance
+   *            and the processor will take the `Root` from it.
+   * @param opts Options.
+   * @return Promise proxy.
+   */
+  process(
+    css: { toString(): string } | LazyResult | Result | Root | string
+  ): LazyResult | NoWorkResult
+  process<RootNode extends Document | Root = Root>(
+    css: { toString(): string } | LazyResult | Result | Root | string,
+    options: ProcessOptions<RootNode>
+  ): LazyResult<RootNode>
+
+  /**
+   * Adds a plugin to be used as a CSS processor.
+   *
+   * PostCSS plugin can be in 4 formats:
+   * * A plugin in `Plugin` format.
+   * * A plugin creator function with `pluginCreator.postcss = true`.
+   *   PostCSS will call this function without argument to get plugin.
+   * * A function. PostCSS will pass the function a {@link Root}
+   *   as the first argument and current `Result` instance
+   *   as the second.
+   * * Another `Processor` instance. PostCSS will copy plugins
+   *   from that instance into this one.
+   *
+   * Plugins can also be added by passing them as arguments when creating
+   * a `postcss` instance (see [`postcss(plugins)`]).
+   *
+   * Asynchronous plugins should return a `Promise` instance.
+   *
+   * ```js
+   * const processor = postcss()
+   *   .use(autoprefixer)
+   *   .use(postcssNested)
+   * ```
+   *
+   * @param plugin PostCSS plugin or `Processor` with plugins.
+   * @return Current processor to make methods chain.
+   */
+  use(plugin: AcceptedPlugin): this
+}
+
+declare class Processor extends Processor_ {}
+
+export = Processor