@runeya/runeya 2.0.76 → 2.0.78

package/{src-MEMRUBM6.js → src-6PAM4JRF.js}

@@ -110,7 +110,7 @@ import {
   wasRead,
   withDeprecatedAliases,
   writeEntity
-} from "./chunk-E2SU5RSO.js";
+} from "./chunk-T3TDCZUY.js";
 
 // ../server/src/create-server.ts
 import express from "express";
@@ -2432,6 +2432,9 @@ var projectRouter = router({
 import { z as z4 } from "zod";
 import { TRPCError as TRPCError4 } from "@trpc/server";
 
+// ../server/src/services/log-parser-store.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
 // ../server/src/services/settings-manager.ts
 import { readFile as readFile7, writeFile as writeFile7, rename as rename7, mkdir as mkdir7, chmod as chmod6 } from "fs/promises";
 import { join as join8 } from "path";
@@ -2569,6 +2572,170 @@ var SettingsManager = class {
 };
 var settingsManager = new SettingsManager();
 
+// ../server/src/services/log-parser-store.ts
+function isShareable(parser) {
+  return parser.builtin !== true && !parser.id.startsWith("native:");
+}
+var LogParserStore = class {
+  localListeners = /* @__PURE__ */ new Set();
+  changeListeners = /* @__PURE__ */ new Set();
+  /**
+   * S'abonner aux écritures *locales* — celles nées ici.
+   *
+   * C'est ce qu'écoute la synchronisation : réagir aussi à ce qui arrive du
+   * document la ferait repartir aussitôt vers ce document, en boucle.
+   */
+  onLocalChange(fn) {
+    this.localListeners.add(fn);
+    return () => this.localListeners.delete(fn);
+  }
+  /**
+   * S'abonner à toute écriture, d'où qu'elle vienne.
+   *
+   * C'est ce qu'écoute l'interface : un parseur écrit par un collègue arrive
+   * par le document, donc silencieusement pour la synchronisation — mais un
+   * écran qui ne l'apprend qu'au prochain montage montre une liste fausse
+   * pendant tout ce temps, alors même que les services, eux, se rafraîchissent.
+   */
+  onChanged(fn) {
+    this.changeListeners.add(fn);
+    return () => this.changeListeners.delete(fn);
+  }
+  notify(vault, local) {
+    if (local) {
+      for (const fn of this.localListeners) {
+        try {
+          fn();
+        } catch (err) {
+          console.error("[log-parser-store] listener failed:", err.message);
+        }
+      }
+    }
+    for (const fn of this.changeListeners) {
+      try {
+        fn(vault);
+      } catch (err) {
+        console.error("[log-parser-store] listener failed:", err.message);
+      }
+    }
+  }
+  /** Les parseurs d'un coffre — ceux de l'organisation, ou ceux du poste. */
+  async list(vault) {
+    const settings = await settingsManager.getSettings(vault);
+    return settings.logParsers ?? [];
+  }
+  async get(id, vault) {
+    return (await this.list(vault)).find((p) => p.id === id) ?? null;
+  }
+  async write(parsers, vault, silent = false) {
+    const settings = await settingsManager.getSettings(vault);
+    await settingsManager.saveSettings({ ...settings, logParsers: parsers }, vault);
+    this.notify(vault, !silent);
+  }
+  async create(input, vault) {
+    const now = /* @__PURE__ */ new Date();
+    if (input.builtin) {
+      throw new Error("A parser created here is never a built-in one");
+    }
+    const parser = JSLogParserSchema.parse({
+      ...input,
+      id: randomUUID3(),
+      createdAt: now,
+      updatedAt: now
+    });
+    await this.write([...await this.list(vault), parser], vault);
+    return parser;
+  }
+  async update(id, patch, vault) {
+    const parsers = await this.list(vault);
+    const index = parsers.findIndex((p) => p.id === id);
+    if (index === -1) return null;
+    const updated = JSLogParserSchema.parse({
+      ...parsers[index],
+      ...patch,
+      id,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    const next = [...parsers];
+    next[index] = updated;
+    await this.write(next, vault);
+    return updated;
+  }
+  async delete(id, vault) {
+    const parsers = await this.list(vault);
+    const next = parsers.filter((p) => p.id !== id);
+    if (next.length === parsers.length) return false;
+    await this.write(next, vault);
+    return true;
+  }
+  // ---- Synchronisation --------------------------------------------------
+  /**
+   * Écrire ce que le document de l'organisation porte.
+   *
+   * Silencieux et gardé par une comparaison : réveiller les écoutants ici
+   * relancerait la réconciliation qui vient de produire cette écriture, et un
+   * document identique au disque ne mérite pas un fichier réécrit.
+   */
+  async applyRemoteUpsert(id, fields, orgId) {
+    const parsed = JSLogParserSchema.safeParse({ ...fields, id });
+    if (!parsed.success) {
+      console.warn("[log-parser-store] rejected a remote parser %s: %s", id, parsed.error.message);
+      return;
+    }
+    if (!isShareable(parsed.data)) return;
+    const parsers = await this.list(orgId);
+    const index = parsers.findIndex((p) => p.id === id);
+    if (index !== -1 && sameParser(parsers[index], parsed.data)) return;
+    const next = [...parsers];
+    if (index === -1) next.push(parsed.data);
+    else next[index] = parsed.data;
+    await this.write(next, orgId, true);
+  }
+  async applyRemoteDelete(id, orgId) {
+    const parsers = await this.list(orgId);
+    const next = parsers.filter((p) => p.id !== id);
+    if (next.length === parsers.length) return;
+    await this.write(next, orgId, true);
+  }
+  /**
+   * Remonter les parseurs du poste dans les organisations de cette machine.
+   *
+   * Un déplacement, pas une copie : le même parseur des deux côtés ferait deux
+   * vérités qui divergent au premier changement, et la liste du poste
+   * ressusciterait à chaque connexion celui qu'un membre vient de supprimer
+   * pour toute l'équipe. Une fois la machine vidée, il n'y a plus rien à
+   * remonter — l'opération peut donc être rejouée sans dégât.
+   *
+   * Vers *toutes* les organisations liées, chacune recevant sa copie : les
+   * coffres ne communiquent pas, et rien ne dit laquelle des deux était visée.
+   */
+  async migrateMachineParsersInto(orgIds) {
+    if (orgIds.length === 0) return;
+    const all = await this.list();
+    if (all.length === 0) return;
+    const machineParsers = all.filter(isShareable);
+    for (const orgId of orgIds) {
+      const existing = await this.list(orgId);
+      const known = new Set(existing.map((p) => p.id));
+      const added = machineParsers.filter((p) => !known.has(p.id));
+      if (added.length === 0) continue;
+      await this.write([...existing, ...added], orgId, true);
+    }
+    await this.write(all.filter((p) => !isShareable(p)), void 0, true);
+    if (machineParsers.length > 0) {
+      console.log(
+        "[log-parser-store] moved %d machine parser(s) into organization(s): %s",
+        machineParsers.length,
+        orgIds.join(", ")
+      );
+    }
+  }
+};
+function sameParser(a, b) {
+  return a.name === b.name && a.code === b.code && a.enabled === b.enabled && (a.description ?? "") === (b.description ?? "") && a.updatedAt.getTime() === b.updatedAt.getTime();
+}
+var logParserStore = new LogParserStore();
+
 // ../server/src/services/service-builtins.ts
 function buildServerBuiltins(input) {
   const { service, siblings, projectName, environmentName, agentName, host } = input;
@@ -2609,7 +2776,7 @@ import { isAbsolute as isAbsolute3 } from "path";
 import { isAbsolute as isAbsolute2, join as join10, dirname as dirname5 } from "path";
 
 // ../server/src/services/conversation-store.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { readFile as readFile8, writeFile as writeFile8, rename as rename8, mkdir as mkdir8, chmod as chmod7 } from "fs/promises";
 import { dirname as dirname4, join as join9 } from "path";
 import { EventEmitter as EventEmitter2 } from "events";
@@ -2942,7 +3109,7 @@ ${new Error("trace").stack}`
     await this.load();
     const now = Date.now();
     const conv = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       projectId,
       title: title ?? "New conversation",
       messages: [],
@@ -3104,8 +3271,9 @@ async function resolveServiceVariables(service) {
   }
   try {
     if (service.parserIds && service.parserIds.length > 0) {
-      const settings = await settingsManager.getSettings();
-      const allParsers = [...nativeParsers, ...settings.logParsers || []];
+      const vault = project?.orgId ?? void 0;
+      const parsers = await logParserStore.list(vault);
+      const allParsers = [...nativeParsers, ...parsers];
       const resolvedParsers = service.parserIds.map((id) => allParsers.find((p) => p.id === id)).filter((p) => p !== void 0);
       resolvedService = { ...resolvedService, resolvedLogParsers: resolvedParsers };
     }
@@ -4556,6 +4724,12 @@ async function setLanMode(enabled) {
 
 // ../server/src/trpc/routers/settings.ts
 var NotificationPreferencesPatchSchema = NotificationPreferencesSchema.partial().strict();
+function listWithOrigin(parsers, vault) {
+  return [
+    ...nativeParsers.map((p) => ({ ...p, origin: "native" })),
+    ...parsers.map((p) => ({ ...p, origin: vault ? "org" : "machine" }))
+  ];
+}
 function maskApiKey2(plaintext) {
   if (plaintext.length <= 8) return "****";
   return plaintext.slice(0, 4) + "****" + plaintext.slice(-4);
@@ -4648,17 +4822,63 @@ var settingsRouter = router({
   }),
   /**
    * List all parsers
+   *
+   * Les natifs, puis ceux du coffre visé. L'origine accompagne chacun : un
+   * parseur d'organisation se modifie pour toute l'équipe, et l'interface doit
+   * pouvoir le dire avant que quelqu'un le change sans le savoir.
    */
-  listParsers: protectedProcedure.query(async () => {
-    const settings = await settingsManager.getSettings();
-    return [...nativeParsers, ...settings.logParsers || []];
+  listParsers: protectedProcedure.input(z11.object(ScopeShape).optional()).query(async ({ input }) => {
+    const vault = await scopeOf(input);
+    return listWithOrigin(await logParserStore.list(vault), vault);
+  }),
+  /**
+   * Les parseurs du coffre visé, à chaque fois qu'ils changent.
+   *
+   * Les services arrivent en temps réel, et un parseur écrit par un collègue
+   * atteint le disque tout aussi vite ; sans ce flux, seul l'écran resterait en
+   * retard — affichant une liste dans laquelle le parseur qu'un service vient
+   * de référencer n'existe pas encore.
+   */
+  onParsersChanged: protectedProcedure.input(z11.object(ScopeShape).optional()).subscription(async function* ({ input, signal }) {
+    const vault = await scopeOf(input);
+    let pending = true;
+    let wake = null;
+    const off = logParserStore.onChanged((touched) => {
+      if (touched !== vault) return;
+      pending = true;
+      if (wake) {
+        wake();
+        wake = null;
+      }
+    });
+    const onAbort = () => {
+      if (wake) {
+        wake();
+        wake = null;
+      }
+    };
+    signal?.addEventListener("abort", onAbort);
+    try {
+      while (!signal?.aborted) {
+        if (pending) {
+          pending = false;
+          yield listWithOrigin(await logParserStore.list(vault), vault);
+        } else {
+          await new Promise((resolve7) => {
+            wake = resolve7;
+          });
+        }
+      }
+    } finally {
+      off();
+      signal?.removeEventListener("abort", onAbort);
+    }
   }),
   /**
    * Get single parser by ID
    */
-  getParser: protectedProcedure.input(z11.object({ id: z11.string().max(128) })).query(async ({ input }) => {
-    const settings = await settingsManager.getSettings();
-    const parser = (settings.logParsers || []).find((p) => p.id === input.id);
+  getParser: protectedProcedure.input(z11.object({ id: z11.string().max(128), ...ScopeShape })).query(async ({ input }) => {
+    const parser = await logParserStore.get(input.id, await scopeOf(input));
     if (!parser) {
       throw new TRPCError8({ code: "NOT_FOUND", message: `Parser not found: ${input.id}` });
     }
@@ -4672,25 +4892,13 @@ var settingsRouter = router({
       id: true,
       createdAt: true,
       updatedAt: true
-    })
+    }).extend(ScopeShape)
   ).mutation(async ({ input }) => {
-    if (!input.code.trim()) {
+    const { orgId, projectId, ...fields } = input;
+    if (!fields.code.trim()) {
       throw new TRPCError8({ code: "BAD_REQUEST", message: "Parser code cannot be empty" });
     }
-    const id = `parser-${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    const now = /* @__PURE__ */ new Date();
-    const parser = {
-      id,
-      ...input,
-      createdAt: now,
-      updatedAt: now
-    };
-    const settings = await settingsManager.getSettings();
-    await settingsManager.saveSettings({
-      ...settings,
-      logParsers: [...settings.logParsers || [], parser]
-    });
-    return parser;
+    return logParserStore.create(fields, await scopeOf({ orgId, projectId }));
   }),
   /**
    * Update existing parser
@@ -4699,53 +4907,32 @@ var settingsRouter = router({
     JSLogParserSchema.omit({
       createdAt: true,
       updatedAt: true
-    }).partial().required({ id: true })
+    }).partial().required({ id: true }).extend(ScopeShape)
   ).mutation(async ({ input }) => {
-    const settings = await settingsManager.getSettings();
-    const parserIndex = (settings.logParsers || []).findIndex(
-      (p) => p.id === input.id
-    );
-    if (parserIndex === -1) {
-      throw new TRPCError8({ code: "NOT_FOUND", message: `Parser not found: ${input.id}` });
-    }
-    if (input.id.startsWith("native:")) {
+    const { id, orgId, projectId, ...patch } = input;
+    if (id.startsWith("native:")) {
       throw new TRPCError8({ code: "FORBIDDEN", message: "Cannot modify built-in parsers" });
     }
-    const existing = (settings.logParsers || [])[parserIndex];
-    if (input.code && !input.code.trim()) {
+    if (patch.code !== void 0 && !patch.code.trim()) {
       throw new TRPCError8({ code: "BAD_REQUEST", message: "Parser code cannot be empty" });
     }
-    const updated = {
-      ...existing,
-      ...input,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    const newParsers = [...settings.logParsers || []];
-    newParsers[parserIndex] = updated;
-    await settingsManager.saveSettings({
-      ...settings,
-      logParsers: newParsers
-    });
+    const updated = await logParserStore.update(id, patch, await scopeOf({ orgId, projectId }));
+    if (!updated) {
+      throw new TRPCError8({ code: "NOT_FOUND", message: `Parser not found: ${id}` });
+    }
     return updated;
   }),
   /**
    * Delete parser by ID
    */
-  deleteParser: protectedProcedure.input(z11.object({ id: z11.string().max(128) })).mutation(async ({ input }) => {
-    const settings = await settingsManager.getSettings();
-    const newParsers = (settings.logParsers || []).filter(
-      (p) => p.id !== input.id
-    );
+  deleteParser: protectedProcedure.input(z11.object({ id: z11.string().max(128), ...ScopeShape })).mutation(async ({ input }) => {
     if (input.id.startsWith("native:")) {
       throw new TRPCError8({ code: "FORBIDDEN", message: "Cannot delete built-in parsers" });
     }
-    if (newParsers.length === (settings.logParsers || []).length) {
+    const deleted = await logParserStore.delete(input.id, await scopeOf(input));
+    if (!deleted) {
       throw new TRPCError8({ code: "NOT_FOUND", message: `Parser not found: ${input.id}` });
     }
-    await settingsManager.saveSettings({
-      ...settings,
-      logParsers: newParsers
-    });
     return { deleted: true };
   }),
   // ---------------------------------------------------------------------------
@@ -5447,6 +5634,24 @@ import { promisify as promisify3 } from "util";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // ../../packages/ai-capabilities/src/capabilities.ts
+function toList(raw) {
+  if (!raw) return [];
+  const text = raw.trim();
+  if (text.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(text);
+      if (Array.isArray(parsed)) return parsed.map((v) => String(v).trim()).filter(Boolean);
+    } catch {
+    }
+  }
+  return text.split(",").map((v) => v.trim().replace(/^["'[]+|["'\]]+$/g, "")).filter(Boolean);
+}
+function clearable(raw, parse2, key) {
+  if (raw === void 0) return {};
+  const text = String(raw).trim();
+  if (!text || text === "null") return { [key]: null };
+  return { [key]: parse2(text) };
+}
 var RUNEYA_CAPABILITIES = [
   {
     name: "list_services",
@@ -5570,11 +5775,11 @@ var RUNEYA_CAPABILITIES = [
   },
   {
     name: "kanban_search_cards",
-    description: "Search kanban cards by free text, matched against their title and body (accent- and case-insensitive). Searches every board of the organization unless boardId narrows it down.",
+    description: "Search kanban cards by free text, matched against their title, body and comments (accent- and case-insensitive). Archived cards are included. Searches every board of the organization unless boardId narrows it down.",
     route: "kanban.searchCards",
     method: "GET",
     params: [
-      { name: "query", description: "Text to look for in card titles and bodies", required: true },
+      { name: "query", description: "Text to look for in card titles, bodies and comments", required: true },
       { name: "boardId", description: "Restrict the search to this board. Omit to search all boards.", required: false },
       { name: "limit", description: "Maximum number of cards to return (1-100). Default: 25.", required: false },
       { name: "organizationId", description: "Which organization to search. Optional: needed only when the account belongs to several and the error message asks for it.", required: false }
@@ -5660,6 +5865,71 @@ var RUNEYA_CAPABILITIES = [
       { name: "content", description: "Card content in markdown", required: false }
     ],
     buildInput: (p) => ({ boardId: p.boardId, column: p.column, title: p.title, content: p.content })
+  },
+  {
+    name: "kanban_get_card",
+    description: "Read one kanban card by id, including archived ones. Cheaper than fetching the whole board, and the only way to read a card that has been archived.",
+    route: "kanban.getCard",
+    method: "GET",
+    params: [
+      { name: "boardId", description: "The kanban board ID", required: true },
+      { name: "cardId", description: "The card ID", required: true }
+    ],
+    buildInput: (p) => ({ boardId: p.boardId, cardId: p.cardId })
+  },
+  {
+    name: "kanban_update_card",
+    description: "Update an existing kanban card. Only the fields you pass are changed; passing null to priority, color or deadline clears it. Prefer this over creating a second card when something needs correcting.",
+    route: "kanban.updateCard",
+    method: "POST",
+    params: [
+      { name: "boardId", description: "The kanban board ID", required: true },
+      { name: "cardId", description: "The card ID", required: true },
+      { name: "title", description: "New title", required: false },
+      { name: "content", description: "New card content, in markdown", required: false },
+      { name: "priority", description: "Priority from 1 to 10, or null to clear it", required: false },
+      { name: "color", description: "Card colour, or null to clear it", required: false },
+      { name: "groups", description: "Labels, as a list of strings. Replaces the current ones.", required: false },
+      { name: "deadline", description: "Due date as YYYY-MM-DD, or null to clear it", required: false },
+      { name: "assignees", description: "User ids to assign, as a list. Replaces the current ones; use kanban_list_members to find the ids.", required: false }
+    ],
+    buildInput: (p) => ({
+      boardId: p.boardId,
+      cardId: p.cardId,
+      ...p.title !== void 0 ? { title: p.title } : {},
+      ...p.content !== void 0 ? { content: p.content } : {},
+      // Tout arrive en chaîne : un modèle n'écrit pas des nombres, des listes
+      // ni des `null` typés. `clearable` distingue « efface » de « ne touche
+      // pas » — sans quoi vider une couleur serait impossible à exprimer, et
+      // changer un titre risquerait de vider le reste.
+      ...clearable(p.priority, (v) => Number(v), "priority"),
+      ...clearable(p.color, (v) => v, "color"),
+      ...clearable(p.deadline, (v) => v, "deadline"),
+      ...p.groups !== void 0 ? { groups: toList(p.groups) } : {},
+      ...p.assignees !== void 0 ? { assignees: toList(p.assignees) } : {}
+    })
+  },
+  {
+    name: "kanban_set_card_archived",
+    description: "Archive a kanban card (it leaves the board but is not deleted) or bring it back. An unarchived card returns to the column it left.",
+    route: "kanban.setCardArchived",
+    method: "POST",
+    params: [
+      { name: "boardId", description: "The kanban board ID", required: true },
+      { name: "cardId", description: "The card ID", required: true },
+      { name: "archived", description: "true to archive, false to bring the card back", required: true }
+    ],
+    buildInput: (p) => ({ boardId: p.boardId, cardId: p.cardId, archived: p.archived === "true" })
+  },
+  {
+    name: "kanban_list_members",
+    description: "List the people of the organization who can be assigned to a card, with their ids. Needed before assigning anyone with kanban_update_card.",
+    route: "kanban.listMembers",
+    method: "GET",
+    params: [
+      { name: "organizationId", description: "Which organization. Optional: needed only when the account belongs to several and the error message asks for it.", required: false }
+    ],
+    buildInput: (p) => p.organizationId ? { organizationId: p.organizationId } : {}
   }
 ];
 
@@ -7223,7 +7493,7 @@ async function fetchProviderModels(provider, plaintextKey) {
 }
 
 // ../server/src/services/image-storage.service.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { mkdir as mkdir15, writeFile as writeFile14, readFile as readFile15, unlink as unlink3, readdir as readdir4 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { join as join18, extname, resolve as resolve4, sep as sep2 } from "path";
@@ -7260,7 +7530,7 @@ var ImageStorageService = class {
       throw new Error(`Unsupported extension: ${ext}`);
     }
     await this.ensureTmpDir();
-    const imageId = randomUUID4();
+    const imageId = randomUUID5();
     const safeExt = ext.replace(/[^a-z.]/g, "");
     const fileName = `${imageId}${safeExt}`;
     const filePath = join18(this.dir, fileName);
@@ -7407,9 +7677,6 @@ async function resolveImagesToBase64(images, contextId) {
   return results.filter((r) => r !== null);
 }
 
-// ../server/src/services/kanban-commands.ts
-import { randomUUID as randomUUID5 } from "crypto";
-
 // ../server/src/trpc/routers/cloud-auth.ts
 import { z as z16 } from "zod";
 import { hostname } from "os";
@@ -7671,6 +7938,76 @@ var KanbanStore = class {
     });
     return { card: res.data?.card ?? null, unsupported: res.status === 404 };
   }
+  /** Une carte, par son identifiant — archivée comprise. */
+  async card(boardId, cardId) {
+    const res = await callCloud(
+      `/kanban/card/get?boardId=${encodeURIComponent(boardId)}&cardId=${encodeURIComponent(cardId)}`
+    );
+    return res.data ?? null;
+  }
+  /**
+   * Modifier une carte.
+   *
+   * L'absence d'un champ ne le touche pas ; `null` l'efface. C'est le contrat du
+   * cloud, et le distinguer ici évite qu'un agent vide une couleur en voulant
+   * simplement changer un titre.
+   */
+  async updateCard(boardId, cardId, patch) {
+    const res = await callCloud("/kanban/card/update", {
+      method: "POST",
+      body: { boardId, cardId, ...patch }
+    });
+    return res.data?.card ?? null;
+  }
+  /** Ranger une carte, ou la reprendre. */
+  async setCardArchived(boardId, cardId, archived) {
+    const res = await callCloud(`/kanban/card/${archived ? "archive" : "unarchive"}`, {
+      method: "POST",
+      body: { boardId, cardId }
+    });
+    return res.ok;
+  }
+  /**
+   * Les membres de l'organisation — sans quoi assigner reviendrait à deviner
+   * un identifiant.
+   */
+  async members(organizationId) {
+    const orgId = await resolveOrganizationId(organizationId);
+    const res = must(
+      await callCloud(
+        `/organization/get-full-organization?organizationId=${encodeURIComponent(orgId)}`
+      )
+    );
+    return (res.members ?? []).map((m) => ({
+      id: m.userId,
+      name: m.user?.name?.trim() || m.user?.email || m.userId,
+      email: m.user?.email ?? ""
+    }));
+  }
+  /**
+   * Chercher des cartes — dans le cloud, pas ici.
+   *
+   * Cette recherche téléchargeait autrefois **tous les tableaux** de
+   * l'organisation, entiers, pour filtrer ensuite en mémoire sur le titre et le
+   * corps. Elle coûtait donc le poids du kanban complet à chaque appel, ne
+   * voyait pas les commentaires — ils ne voyagent plus avec le tableau — et
+   * ignorait les cartes rangées, absentes des colonnes.
+   *
+   * Le cloud fait la même recherche que ses propres écrans : titre, corps et
+   * commentaires, sans casse ni accents.
+   */
+  async searchCards(input) {
+    const orgId = await resolveOrganizationId(input.organizationId);
+    const query = new URLSearchParams({ organizationId: orgId, q: input.query });
+    if (input.boardId) query.set("boardId", input.boardId);
+    if (input.limit) query.set("limit", String(input.limit));
+    const res = must(
+      await callCloud(
+        `/kanban/card/search?${query.toString()}`
+      )
+    );
+    return { cards: res.cards ?? [], total: res.total ?? 0, truncated: Boolean(res.truncated) };
+  }
   /** Déplacer une carte, sans réécrire le tableau. */
   async moveCard(boardId, cardId, toColumnId) {
     const res = await callCloud("/kanban/card/move", {
@@ -7799,27 +8136,9 @@ async function addCardOrFallback(board, columnTitle, cardTitle, cardContent) {
     markdown: cardContent
   });
   if (card) return;
-  if (!unsupported) {
-    console.warn(`[kanban-commands] add_card failed: column="${columnTitle}"`);
-    return;
-  }
-  console.warn("[kanban-commands] cloud sans /kanban/card/add \u2014 repli sur la sauvegarde du tableau");
-  const col = board.columns.find((c) => c.title.toLowerCase() === columnTitle.toLowerCase());
-  if (!col) return;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  col.cards.push({
-    id: randomUUID5(),
-    title: cardTitle,
-    markdown: cardContent ?? "",
-    images: [],
-    attachments: [],
-    assignees: [],
-    order: col.cards.reduce((max, c) => Math.max(max, c.order + 1), 0),
-    history: [{ type: "created", timestamp: now, detail: `AI \u2014 In column "${col.title}"` }],
-    createdAt: now,
-    updatedAt: now
-  });
-  await kanbanStore.update({ id: board.id, columns: board.columns });
+  console.warn(
+    unsupported ? `[kanban-commands] cloud sans /kanban/card/add \u2014 carte \xAB ${cardTitle} \xBB non cr\xE9\xE9e` : `[kanban-commands] add_card failed: column="${columnTitle}"`
+  );
 }
 function formatSize(bytes) {
   if (bytes < 1024) return `${bytes} o`;
@@ -8169,7 +8488,7 @@ function tailTranscript(opts) {
 
 // ../server/src/services/ai-runners/claude-pty-runner.ts
 async function getAgentManager() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-DM6C7BTF.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-KM7SFKVR.js");
   return agentManager2;
 }
 function buildPtyArgs(params, sessionId, opts) {
@@ -8910,7 +9229,7 @@ async function shutdownCodexAppServer() {
   }
 }
 async function getAgentManager2() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-DM6C7BTF.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-KM7SFKVR.js");
   return agentManager2;
 }
 function parseRuneyaCurlCommand(command) {
@@ -13352,11 +13671,6 @@ function summarizeCard(card, boardId, columnTitle) {
     updatedAt: card.updatedAt
   };
 }
-function boardCards(board) {
-  return [...board.columns].sort((a, b) => a.order - b.order).flatMap(
-    (col) => [...col.cards].sort((a, b) => a.order - b.order).map((card) => summarizeCard(card, board.id, col.title))
-  );
-}
 function boardCounts(board) {
   const summary = board;
   const columns = board.columns ?? [];
@@ -13366,9 +13680,6 @@ function boardCounts(board) {
     columns: columns.map((c) => c.title)
   };
 }
-function normalize(value) {
-  return value.normalize("NFD").replace(new RegExp("\\p{Diacritic}", "gu"), "").toLowerCase();
-}
 var ATTACHMENT_ID_REGEX = /^[A-Za-z0-9_-]{1,128}$/;
 function safeDecode(value) {
   try {
@@ -13498,13 +13809,7 @@ var kanbanRouter = router({
     limit: z23.number().int().min(1).max(100).optional(),
     organizationId: z23.string().max(128).optional()
   })).query(async ({ input }) => {
-    const needle = normalize(input.query);
-    const ids = input.boardId ? [input.boardId] : (await kanbanStore.list(false, input.organizationId)).boards.map((b) => b.id);
-    const boards = (await Promise.all(ids.map((id) => kanbanStore.get(id)))).filter((b) => b !== null);
-    const matches = boards.flatMap((board) => boardCards(board).map((card) => ({ board: board.name, ...card }))).filter(
-      (card) => normalize(String(card["title"] ?? "")).includes(needle) || normalize(String(card["markdown"] ?? "")).includes(needle)
-    );
-    return { total: matches.length, cards: matches.slice(0, input.limit ?? 25) };
+    return kanbanStore.searchCards(input);
   }),
   /**
    * Le fil de commentaires d'une carte, relu à la demande.
@@ -13583,7 +13888,7 @@ var kanbanRouter = router({
   addComment: protectedProcedure.input(z23.object({
     boardId: z23.string().max(128),
     cardId: z23.string().max(128),
-    comment: z23.string().max(2e4)
+    comment: z23.string().max(1e5)
   })).mutation(async ({ input }) => {
     await executeKanbanCommands(input.boardId, input.cardId, [
       { type: "add_comment", comment: input.comment }
@@ -13601,6 +13906,62 @@ var kanbanRouter = router({
     ]);
     return { ok: true };
   }),
+  /**
+   * Lire une carte, seule.
+   *
+   * `getBoard` rapatrie le tableau entier pour n'en regarder qu'une ; et il ne
+   * porte pas les cartes rangées. Une carte s'adresse par son identifiant.
+   */
+  getCard: protectedProcedure.input(z23.object({ boardId: z23.string().max(128), cardId: z23.string().max(128) })).query(async ({ input }) => {
+    const found = await kanbanStore.card(input.boardId, input.cardId);
+    if (!found) throw new Error(`Carte ${input.cardId} introuvable sur le tableau ${input.boardId}.`);
+    return { ...summarizeCard(found.card, input.boardId, ""), columnId: found.columnId };
+  }),
+  /**
+   * Modifier une carte.
+   *
+   * Le manque le plus coûteux du kanban vu par un agent : sans lui, il ne
+   * pouvait qu'ajouter. Face à une carte à corriger, il en créait une seconde.
+   *
+   * Un champ absent n'est pas touché ; `null` l'efface. La distinction compte —
+   * changer un titre ne doit pas vider une couleur.
+   */
+  updateCard: protectedProcedure.input(z23.object({
+    boardId: z23.string().max(128),
+    cardId: z23.string().max(128),
+    title: z23.string().min(1).max(512).optional(),
+    content: z23.string().max(1e5).optional(),
+    priority: z23.number().int().min(1).max(10).nullable().optional(),
+    color: z23.string().max(32).nullable().optional(),
+    groups: z23.array(z23.string().min(1).max(60)).max(30).optional(),
+    deadline: z23.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional(),
+    assignees: z23.array(z23.string().max(128)).max(50).optional()
+  })).mutation(async ({ input }) => {
+    const { boardId, cardId, content, ...rest } = input;
+    const patch = { ...rest };
+    if (content !== void 0) patch.markdown = content;
+    if (!Object.keys(patch).length) throw new Error("Rien \xE0 modifier : pr\xE9cisez au moins un champ.");
+    const card = await kanbanStore.updateCard(boardId, cardId, patch);
+    if (!card) throw new Error(`La carte ${cardId} n'a pas pu \xEAtre modifi\xE9e.`);
+    return summarizeCard(card, boardId, "");
+  }),
+  /** Ranger une carte, ou la reprendre. */
+  setCardArchived: protectedProcedure.input(z23.object({
+    boardId: z23.string().max(128),
+    cardId: z23.string().max(128),
+    archived: z23.boolean()
+  })).mutation(async ({ input }) => {
+    const ok = await kanbanStore.setCardArchived(input.boardId, input.cardId, input.archived);
+    if (!ok) throw new Error(`La carte ${input.cardId} n'a pas pu \xEAtre ${input.archived ? "archiv\xE9e" : "reprise"}.`);
+    return { ok: true };
+  }),
+  /**
+   * Qui peut se voir assigner une carte.
+   *
+   * Sans cette liste, assigner revient à deviner un identifiant — et l'agent
+   * n'a aucun moyen de le trouver.
+   */
+  listMembers: protectedProcedure.input(z23.object({ organizationId: z23.string().max(128).optional() })).query(async ({ input }) => ({ members: await kanbanStore.members(input.organizationId) })),
   /**
    * Fetch one card attachment from the cloud and drop it on this machine, so an
    * agent can open it with its own file tools. The bytes never go through the
@@ -14190,6 +14551,7 @@ var RECONNECT_DELAY_MS = 3e3;
 var UNAUTHENTICATED_RETRY_MS = 5 * 6e4;
 var OUTDATED_RETRY_MS = 30 * 6e4;
 var COLLECTIONS = ["projects", "services", "environments"];
+var PARSERS = "logParsers";
 var SyncAuthError = class extends Error {
   constructor(status) {
     super(`cloud rejected the session (HTTP ${status})`);
@@ -14221,6 +14583,7 @@ var OrgSyncConnection = class {
   projects = getCollection(this.doc, "projects");
   services = getCollection(this.doc, "services");
   environments = getCollection(this.doc, "environments");
+  logParsers = getCollection(this.doc, PARSERS);
   conn = randomUUID11();
   link;
   stopped = false;
@@ -14289,9 +14652,14 @@ var OrgSyncConnection = class {
         void this.applyDocEventsToStore(name, events, isInitial);
       });
     }
+    this.logParsers.observeDeep((events, txn) => {
+      if (txn.origin !== REMOTE_ORIGIN) return;
+      void this.applyParserEventsToStore(events);
+    });
     projectStore.events.on("saved", this.onSaved);
     this.unsubscribes.push(serviceStore.onChange(this.onSaved));
     this.unsubscribes.push(environmentStore.onChange(this.onSaved));
+    this.unsubscribes.push(logParserStore.onLocalChange(this.onSaved));
     await this.reconcileLocalToDoc();
     this.initializing = false;
     this.needsPush = true;
@@ -14639,6 +15007,54 @@ var OrgSyncConnection = class {
       await this.upsertLocally(name, id, fields);
     }
   }
+  /**
+   * Nombre d'applications distantes de parseurs en cours.
+   *
+   * La réconciliation lit le coffre et supprime du document ce qu'elle n'y
+   * trouve pas ; déclenchée par un service enregistré au même instant, elle
+   * lirait un coffre où le parseur qui arrive n'est pas encore écrit — et
+   * l'effacerait pour toute l'organisation. Un compteur plutôt qu'un booléen :
+   * plusieurs évènements peuvent se chevaucher, et le premier terminé ne doit
+   * pas rouvrir la porte pour les autres.
+   */
+  applyingParsers = 0;
+  /**
+   * Porter au disque les parseurs que le document vient de changer.
+   *
+   * Une suppression est appliquée telle quelle, sans l'équivalent du garde qui
+   * protège les contenus d'un projet non téléchargé : chaque membre tient le
+   * jeu complet de l'organisation, donc un parseur retiré du document l'a bien
+   * été pour tout le monde.
+   */
+  async applyParserEventsToStore(events) {
+    const deleted = /* @__PURE__ */ new Set();
+    const affected = /* @__PURE__ */ new Set();
+    for (const event of events) {
+      if (event.target === this.logParsers) {
+        for (const [key, change] of event.changes.keys) {
+          if (change.action === "delete") deleted.add(key);
+          else affected.add(key);
+        }
+      } else {
+        const topKey = event.path[0];
+        if (typeof topKey === "string") affected.add(topKey);
+      }
+    }
+    this.applyingParsers += 1;
+    try {
+      for (const id of deleted) {
+        await logParserStore.applyRemoteDelete(id, this.link.orgId);
+      }
+      for (const id of affected) {
+        if (deleted.has(id)) continue;
+        const fields = readEntity(this.logParsers, id);
+        if (!fields) continue;
+        await logParserStore.applyRemoteUpsert(id, fields, this.link.orgId);
+      }
+    } finally {
+      this.applyingParsers -= 1;
+    }
+  }
   async upsertLocally(name, id, fields) {
     if (name === "services") {
       await serviceStore.applyRemoteUpsert(id, fields, this.link.orgId);
@@ -14725,6 +15141,8 @@ var OrgSyncConnection = class {
       environmentStore.listEncryptedByProjectIds(projectIds)
     ]);
     if (this.stopped) return;
+    const parsers = (await logParserStore.list(this.link.orgId)).filter(isShareable);
+    if (this.stopped) return;
     const local = { projects, services, environments };
     const ownedProjectIds = new Set(projectIds);
     this.doc.transact(() => {
@@ -14739,6 +15157,13 @@ var OrgSyncConnection = class {
           if (this.belongsToOwnedProject(name, id, ownedProjectIds)) collection.delete(id);
         }
       }
+      const parserIds = new Set(parsers.map((p) => p.id));
+      for (const parser of parsers) writeEntity(this.logParsers, parser.id, parser);
+      if (this.applyingParsers === 0) {
+        for (const id of Array.from(this.logParsers.keys())) {
+          if (!parserIds.has(id)) this.logParsers.delete(id);
+        }
+      }
     }, LOCAL_ORIGIN);
   }
   /**
@@ -14792,6 +15217,7 @@ var CloudSyncBridge = class {
       console.error("[cloud-sync] could not read which organizations to sync:", err.message);
       return;
     }
+    await this.migrateMachineParsers(links);
     for (const link of links) await this.connect(link);
     const connected = this.connections.size;
     if (links.length > 0) {
@@ -14827,8 +15253,28 @@ var CloudSyncBridge = class {
       console.error("[cloud-sync] could not read which organizations to sync:", err.message);
       return;
     }
+    await this.migrateMachineParsers(links);
     for (const link of links) await this.connect(link);
   }
+  /**
+   * Déplacer les parseurs du poste dans les organisations de cette machine.
+   *
+   * Avant d'ouvrir les connexions, pour que la première réconciliation parte
+   * d'un coffre déjà complet — sinon les parseurs partiraient au document au
+   * coup d'après, ce qui marche mais laisse une fenêtre où l'équipe voit une
+   * liste vide.
+   *
+   * Fait ici plutôt que dans chaque connexion : la liste du poste est vidée à
+   * la fin, et deux connexions qui migreraient en parallèle se la
+   * disputeraient — la seconde trouverait une machine déjà vide.
+   */
+  async migrateMachineParsers(links) {
+    try {
+      await logParserStore.migrateMachineParsersInto(links.map((l) => l.orgId));
+    } catch (err) {
+      console.error("[cloud-sync] could not move machine parsers into organizations:", err.message);
+    }
+  }
   /** Per-org sync state, for the UI. */
   states() {
     const live = Array.from(this.connections.entries()).map(([orgId, conn]) => ({
@@ -17761,4 +18207,4 @@ export {
   pullEnv,
   registerInstance
 };
-//# sourceMappingURL=src-MEMRUBM6.js.map
+//# sourceMappingURL=src-6PAM4JRF.js.map