@runeya/runeya 2.0.144 → 2.0.146

package/{chunk-NSS47H26.js → chunk-UD42LACH.js}

@@ -17,26 +17,21 @@ import {
   serviceStore,
   setProjectServices,
   setProjectVault
-} from "./chunk-GXE5TLLJ.js";
+} from "./chunk-KV4GJKXU.js";
 import {
   atomicWriteSecure,
   fingerprintFiles,
+  forgetFile,
   hasChangedSinceRead,
   rememberFile,
   wasRead
-} from "./chunk-7L6AQUBR.js";
+} from "./chunk-4LJQIQMN.js";
 import {
   findThreadDb,
   lastTurn,
   threadMessages,
   threadsStartedAfter
 } from "./chunk-MD3VW4HQ.js";
-import {
-  COMPANION_RELAY_CLOSE,
-  COMPANION_RELAY_OPEN,
-  ProjectSchema,
-  extractCompanionRelay
-} from "./chunk-XAFOP677.js";
 import {
   allVaultRoots,
   collidesWithMachineRoot,
@@ -57,14 +52,20 @@ import {
   unregisterLocalProjectDir,
   vaultFor,
   vaultIdOfRoot
-} from "./chunk-IXO5KIO5.js";
+} from "./chunk-VPSQJOSN.js";
+import {
+  COMPANION_RELAY_CLOSE,
+  COMPANION_RELAY_OPEN,
+  ProjectSchema,
+  extractCompanionRelay
+} from "./chunk-MZSDTA4A.js";
 
 // ../server/src/services/companion.ts
 import { EventEmitter as EventEmitter4 } from "events";
 
 // ../server/src/services/conversation-store.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { readFile as readFile4, mkdir as mkdir3 } from "fs/promises";
+import { readFile as readFile4, readdir, mkdir as mkdir3, rename as rename3, rm as rm2, stat as stat2 } from "fs/promises";
 import { dirname as dirname2, join as join4 } from "path";
 import { EventEmitter as EventEmitter2 } from "events";
 
@@ -989,6 +990,26 @@ registerProjectLoader(() => projectStore.list().then(() => void 0));
 
 // ../server/src/services/conversation-store.ts
 var FILENAME4 = "conversations.private.json";
+var CONVERSATIONS_DIRNAME = "conversations";
+var FILE_SUFFIX = ".private.json";
+var SAFE_ID_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
+function conversationDir(root) {
+  return join4(root, CONVERSATIONS_DIRNAME);
+}
+function conversationPath(root, id) {
+  return join4(root, CONVERSATIONS_DIRNAME, `${id}${FILE_SUFFIX}`);
+}
+function migratedAggregateName(now) {
+  return `conversations.migrated-${now.toISOString().replace(/[:.]/g, "-").substring(0, 19)}.private.json`;
+}
+async function fileStamp(path) {
+  try {
+    const s = await stat2(path);
+    return `${s.mtimeMs}:${s.size}:${s.ino}`;
+  } catch {
+    return null;
+  }
+}
 async function localProjectId() {
   const projects = await projectStore.list().catch(() => []);
   return projects.find((p) => !p.orgId)?.id ?? null;
@@ -1020,6 +1041,27 @@ var ConversationStore = class {
   fingerprint = "";
   events = new EventEmitter2().setMaxListeners(0);
   disk = new StoreDiskCoordinator();
+  /** Le fichier où chaque conversation est écrite aujourd'hui, s'il existe. */
+  written = /* @__PURE__ */ new Map();
+  /**
+   * Ce qui a été lu de chaque fichier, avec son empreinte.
+   *
+   * Un rechargement ne relit que les fichiers dont l'empreinte a bougé :
+   * déchiffrer toutes les conversations parce qu'une seule a changé dans une
+   * autre fenêtre coûterait autant que l'ancien format.
+   */
+  parsed = /* @__PURE__ */ new Map();
+  /** Les conversations modifiées depuis la dernière écriture. */
+  dirty = /* @__PURE__ */ new Set();
+  /** Les fichiers à retirer : conversations supprimées ou changées de coffre. */
+  removed = /* @__PURE__ */ new Set();
+  /** Les anciens fichiers à convertir, relevés au dernier chargement. */
+  aggregates = [];
+  /** Écrites telles quelles à la conversion : illisibles ici, mais pas perdues. */
+  rawToWrite = /* @__PURE__ */ new Map();
+  /** Plus récentes dans un ancien fichier que dans le leur : à réécrire à la conversion. */
+  outdated = /* @__PURE__ */ new Set();
+  migrating = null;
   snapshotConversation(conv) {
     return structuredClone(conv);
   }
@@ -1099,6 +1141,8 @@ ${new Error("trace").stack}`
       agentId: conv.agentId,
       companionEnabled: conv.companionEnabled,
       companionRunner: conv.companionRunner,
+      companionModel: conv.companionModel,
+      companionEffort: conv.companionEffort,
       companionConversationId: conv.companionConversationId,
       companionBaseSha: conv.companionBaseSha,
       isCompanion: conv.isCompanion,
@@ -1129,6 +1173,8 @@ ${new Error("trace").stack}`
       agentId: disk.agentId,
       companionEnabled: disk.companionEnabled,
       companionRunner: disk.companionRunner,
+      companionModel: disk.companionModel,
+      companionEffort: disk.companionEffort,
       companionConversationId: disk.companionConversationId,
       companionBaseSha: disk.companionBaseSha,
       isCompanion: disk.isCompanion,
@@ -1158,8 +1204,24 @@ ${new Error("trace").stack}`
     ];
     return all.filter((source, i) => !all.slice(i + 1).some((later) => later.path === source.path));
   }
+  /**
+   * Les répertoires où chercher des conversations : ceux des sources, sans
+   * doublon. Le dossier de lancement hérité en fait partie.
+   */
+  async sourceRoots() {
+    return Array.from(new Set((await this.sourcePaths()).map((s) => dirname2(s.path))));
+  }
+  /**
+   * L'état du disque : les anciens fichiers, et les dossiers `conversations/`.
+   *
+   * La date d'un dossier bouge à chaque fichier ajouté, renommé ou retiré, et
+   * toute écriture passe par un renommage (`atomicWriteSecure`). Quelques
+   * `stat` suffisent donc à savoir si une autre instance a écrit.
+   */
   async diskFingerprint() {
-    return fingerprintFiles((await this.sourcePaths()).map((s) => s.path));
+    const paths = (await this.sourcePaths()).map((s) => s.path);
+    const dirs = Array.from(new Set(paths.map((path) => conversationDir(dirname2(path)))));
+    return fingerprintFiles([...paths, ...dirs]);
   }
   async load() {
     if (!getEncryptionKey()) {
@@ -1173,25 +1235,105 @@ ${new Error("trace").stack}`
       return () => {
         this.conversations = next.conversations;
         this.roots = next.roots;
+        this.written = next.written;
+        this.parsed = next.parsed;
         this.unreadable = next.unreadable;
+        this.aggregates = next.aggregates;
+        this.rawToWrite = next.rawToWrite;
+        this.outdated = next.outdated;
         this.fingerprint = fingerprint;
         this.loaded = true;
       };
     });
+    if (this.aggregates.length > 0) await this.migrateAggregates();
+  }
+  /**
+   * Passer les anciens fichiers au format « un fichier par conversation ».
+   *
+   * Dans cet ordre, pour ne rien perdre si ça s'arrête en route : chaque
+   * conversation qui n'a pas encore son fichier l'obtient, les illisibles
+   * compris (recopiées telles quelles), puis on vérifie que tous les fichiers
+   * attendus existent. Alors seulement l'ancien fichier est renommé. Il reste
+   * dans le coffre comme copie de secours, sous un nom que ce store ne lit pas.
+   *
+   * Le fichier du dossier de lancement hérité est renommé lui aussi : relu à
+   * chaque démarrage, il ferait revenir les conversations supprimées depuis.
+   */
+  migrateAggregates() {
+    this.migrating ??= (async () => {
+      const aggregates = this.aggregates;
+      const expected = [];
+      let incomplete = false;
+      for (const [id] of this.conversations) {
+        if (!this.written.has(id) || this.outdated.has(id)) this.dirty.add(id);
+      }
+      await this.save();
+      for (const [id, conv] of this.conversations) {
+        const path = this.written.get(id);
+        if (path) {
+          expected.push(path);
+        } else {
+          incomplete = true;
+          console.warn(`[conversation-store] Conversation ${conv.id} non convertie : ancien fichier gard\xE9.`);
+        }
+      }
+      const raws = Array.from(this.rawToWrite.values());
+      for (const { root, item } of raws) {
+        if (!SAFE_ID_RE.test(item.id)) {
+          incomplete = true;
+          continue;
+        }
+        const path = conversationPath(root, item.id);
+        if (!await fileStamp(path)) await atomicWriteSecure(path, JSON.stringify(item));
+        expected.push(path);
+      }
+      const missing = (await Promise.all(expected.map(fileStamp))).some((st) => st === null);
+      this.aggregates = [];
+      if (missing || incomplete) {
+        console.error("[conversation-store] Conversion incompl\xE8te : les anciens fichiers restent en place.");
+        return;
+      }
+      const now = /* @__PURE__ */ new Date();
+      for (const { path } of aggregates) {
+        await rename3(path, join4(dirname2(path), migratedAggregateName(now)));
+        forgetFile(path);
+        console.log(`[conversation-store] ${path} converti en un fichier par conversation.`);
+      }
+      this.rawToWrite = /* @__PURE__ */ new Map();
+      this.outdated = /* @__PURE__ */ new Set();
+      this.fingerprint = await this.diskFingerprint();
+    })().finally(() => {
+      this.migrating = null;
+    });
+    return this.migrating;
   }
   /** Lire toutes les sources dans des tables neuves, que `load` substitue d'un coup. */
   async readSources() {
     const conversations = /* @__PURE__ */ new Map();
     const roots = /* @__PURE__ */ new Map();
+    const written = /* @__PURE__ */ new Map();
+    const parsed = /* @__PURE__ */ new Map();
     const unreadable = /* @__PURE__ */ new Map();
-    for (const { path, legacy } of await this.sourcePaths()) {
+    const aggregates = [];
+    const rawToWrite = /* @__PURE__ */ new Map();
+    const outdated = /* @__PURE__ */ new Set();
+    const markUnreadable = (root, item) => {
+      const bucket = unreadable.get(root) ?? [];
+      if (!bucket.some((kept) => kept.id === item.id)) bucket.push(item);
+      unreadable.set(root, bucket);
+    };
+    const sources = await this.sourcePaths();
+    const legacyRoots = new Set(sources.filter((s) => s.legacy).map((s) => dirname2(s.path)));
+    const inheritedProject = legacyRoots.size > 0 ? await localProjectId() : null;
+    for (const { path, legacy } of sources) {
       let data;
       try {
         data = JSON.parse(await readFile4(path, "utf-8"));
       } catch {
         continue;
       }
-      const inherited = legacy ? await localProjectId() : null;
+      aggregates.push({ path });
+      const inherited = legacy ? inheritedProject : null;
       const root = dirname2(path);
       await rememberFile(path);
       for (const item of data) {
@@ -1201,13 +1343,62 @@ ${new Error("trace").stack}`
           conversations.set(item.id, conv);
           roots.set(item.id, root);
         } catch {
-          const bucket = unreadable.get(root) ?? [];
-          if (!bucket.some((kept) => kept.id === item.id)) bucket.push(item);
-          unreadable.set(root, bucket);
+          markUnreadable(root, item);
+          if (!rawToWrite.has(item.id)) rawToWrite.set(item.id, { root, item });
         }
       }
     }
-    return { conversations, roots, unreadable };
+    for (const root of await this.sourceRoots()) {
+      const dir = conversationDir(root);
+      let names;
+      try {
+        names = (await readdir(dir)).filter((n) => n.endsWith(FILE_SUFFIX));
+      } catch {
+        continue;
+      }
+      for (const name of names) {
+        const path = join4(dir, name);
+        const stamp = await fileStamp(path);
+        if (!stamp) continue;
+        let entry = this.parsed.get(path);
+        if (!entry || entry.stamp !== stamp) {
+          let item2;
+          try {
+            item2 = JSON.parse(await readFile4(path, "utf-8"));
+          } catch {
+            continue;
+          }
+          let conv2 = null;
+          try {
+            conv2 = this.fromDisk(item2, vaultIdOfRoot(root));
+          } catch {
+            conv2 = null;
+          }
+          entry = { stamp, conv: conv2, item: item2 };
+        }
+        await rememberFile(path);
+        parsed.set(path, entry);
+        const { conv, item } = entry;
+        rawToWrite.delete(item.id);
+        if (!conv) {
+          markUnreadable(root, item);
+          continue;
+        }
+        if (!conv.projectId && legacyRoots.has(root) && inheritedProject) conv.projectId = inheritedProject;
+        written.set(conv.id, path);
+        const older = conversations.get(conv.id);
+        if (older && older.updatedAt > conv.updatedAt) {
+          outdated.add(conv.id);
+          continue;
+        }
+        conversations.set(conv.id, conv);
+        roots.set(conv.id, root);
+      }
+    }
+    for (const [id, conv] of conversations) {
+      if (written.has(id)) rawToWrite.delete(conv.id);
+    }
+    return { conversations, roots, written, parsed, unreadable, aggregates, rawToWrite, outdated };
   }
   /**
    * Oublier ce qui a été lu, pour tout relire sous la clé courante.
@@ -1222,6 +1413,12 @@ ${new Error("trace").stack}`
     this.conversations.clear();
     this.roots.clear();
     this.unreadable.clear();
+    this.written.clear();
+    this.parsed.clear();
+    this.dirty.clear();
+    this.aggregates = [];
+    this.rawToWrite.clear();
+    this.outdated.clear();
     this.loaded = false;
     this.events.emit("changed", { type: "reloaded" });
   }
@@ -1239,43 +1436,52 @@ ${new Error("trace").stack}`
     return out;
   }
   /**
-   * Write each vault that holds — or held — a conversation.
+   * Écrire les conversations modifiées, chacune dans son fichier.
    *
-   * A vault emptied by this save is still written, as an empty list: a
-   * conversation that found its project must not survive in the file it was
-   * read from.
+   * Seules celles qui ont bougé depuis la dernière écriture : c'est le but du
+   * format. Une conversation dont le projet a changé de coffre est écrite dans
+   * le nouveau, et son ancien fichier retiré.
+   *
+   * Un fichier modifié depuis sa lecture (réparation faite à la main, clé
+   * adoptée) n'est pas réécrit : réémettre notre copie déferait la réparation.
    */
   async saveInternal() {
     if (!getEncryptionKey()) return;
-    const byRoot = /* @__PURE__ */ new Map();
-    for (const root of this.roots.values()) byRoot.set(root, []);
-    for (const conv of this.conversations.values()) {
+    const ids = Array.from(this.dirty);
+    this.dirty.clear();
+    const removed = Array.from(this.removed);
+    this.removed.clear();
+    for (const id of ids) {
+      const conv = this.conversations.get(id);
+      if (!conv) continue;
+      if (!SAFE_ID_RE.test(conv.id)) {
+        console.error(`[conversation-store] Id de conversation refus\xE9 comme nom de fichier : ${JSON.stringify(conv.id)}`);
+        continue;
+      }
       const root = await this.rootFor(conv);
       this.roots.set(conv.id, root);
-      const bucket = byRoot.get(root) ?? [];
       const vault = vaultIdOfRoot(root);
       if (!this.isVaultNamed(root, vault)) continue;
-      bucket.push(this.toDisk(conv, vault));
-      byRoot.set(root, bucket);
-    }
-    for (const [root, items] of this.unreadable) {
-      byRoot.set(root, [...items, ...byRoot.get(root) ?? []]);
-    }
-    const stale = /* @__PURE__ */ new Set();
-    for (const root of byRoot.keys()) {
-      const path = join4(root, FILENAME4);
-      if (wasRead(path) && await hasChangedSinceRead(path)) stale.add(root);
-    }
-    for (const [root, data] of byRoot) {
-      const filePath = join4(root, FILENAME4);
-      if (stale.has(root)) {
+      const path = conversationPath(root, conv.id);
+      if (wasRead(path) && await hasChangedSinceRead(path)) {
         console.warn(
-          `[conversation-store] ${filePath} a chang\xE9 depuis sa lecture \u2014 \xE9criture ignor\xE9e pour ne pas \xE9craser une r\xE9paration faite en dehors du serveur.`
+          `[conversation-store] ${path} a chang\xE9 depuis sa lecture \u2014 \xE9criture ignor\xE9e pour ne pas \xE9craser une r\xE9paration faite en dehors du serveur.`
         );
         continue;
       }
-      await atomicWriteSecure(filePath, JSON.stringify(data, null, 2));
-      await rememberFile(filePath);
+      const item = this.toDisk(conv, vault);
+      await atomicWriteSecure(path, JSON.stringify(item));
+      await rememberFile(path);
+      const stamp = await fileStamp(path);
+      if (stamp) this.parsed.set(path, { stamp, conv, item });
+      const previous = this.written.get(conv.id);
+      this.written.set(conv.id, path);
+      if (previous && previous !== path) removed.push(previous);
+    }
+    for (const path of removed) {
+      await rm2(path, { force: true });
+      forgetFile(path);
+      this.parsed.delete(path);
     }
     this.fingerprint = await this.diskFingerprint();
   }
@@ -1311,9 +1517,11 @@ ${new Error("trace").stack}`
    */
   async relocateAll() {
     await this.load();
-    await this.save();
+    await this.save(...this.conversations.keys());
   }
-  save() {
+  /** Écrire ces conversations — et celles qui attendaient déjà. */
+  save(...ids) {
+    for (const id of ids) this.dirty.add(id);
     return this.disk.save(() => this.saveInternal());
   }
   async list() {
@@ -1376,6 +1584,8 @@ ${new Error("trace").stack}`
       isCompanion: extra?.isCompanion,
       companionEnabled: extra?.companionEnabled,
       companionRunner: extra?.companionRunner,
+      companionModel: extra?.companionModel,
+      companionEffort: extra?.companionEffort,
       createdAt: now,
       updatedAt: now
     };
@@ -1383,7 +1593,7 @@ ${new Error("trace").stack}`
     if (projectId && orgId !== void 0) {
       this.roots.set(conv.id, vaultFor({ id: projectId, orgId }).root);
     }
-    await this.save();
+    await this.save(conv.id);
     this.events.emit("changed", { type: "created", conversation: this.snapshotConversation(conv) });
     return conv;
   }
@@ -1399,10 +1609,12 @@ ${new Error("trace").stack}`
     if (patch.codexThreadId !== void 0) conv.codexThreadId = patch.codexThreadId;
     if (patch.companionEnabled !== void 0) conv.companionEnabled = patch.companionEnabled;
     if (patch.companionRunner !== void 0) conv.companionRunner = patch.companionRunner;
+    if (patch.companionModel !== void 0) conv.companionModel = patch.companionModel || void 0;
+    if (patch.companionEffort !== void 0) conv.companionEffort = patch.companionEffort || void 0;
     if (patch.companionConversationId !== void 0) conv.companionConversationId = patch.companionConversationId;
     if (patch.companionBaseSha !== void 0) conv.companionBaseSha = patch.companionBaseSha;
     if (options?.touch !== false) conv.updatedAt = Date.now();
-    await this.save();
+    await this.save(conv.id);
     if (!options?.silent) {
       this.events.emit("changed", { type: "updated", conversation: this.snapshotConversation(conv), messagesChanged: patch.messages !== void 0 });
     }
@@ -1420,7 +1632,7 @@ ${new Error("trace").stack}`
     lastMsg.content = content;
     if (parts !== void 0) lastMsg.parts = parts;
     conv.updatedAt = Date.now();
-    this.save().catch(() => {
+    this.save(conv.id).catch(() => {
     });
   }
   async listByKanbanBoardId(boardId) {
@@ -1452,7 +1664,7 @@ ${new Error("trace").stack}`
       const ranks = Array.from(this.conversations.values()).map((c) => c.pinOrder).filter((r) => r !== void 0);
       conv.pinOrder = ranks.length > 0 ? Math.max(...ranks) + 1 : 0;
     }
-    await this.save();
+    await this.save(conv.id);
     this.events.emit("changed", { type: "updated", conversation: this.snapshotConversation(conv) });
     return conv;
   }
@@ -1473,7 +1685,7 @@ ${new Error("trace").stack}`
     targets.forEach((conv, i) => {
       conv.pinOrder = ranks[i];
     });
-    await this.save();
+    await this.save(...targets.map((c) => c.id));
     for (const conv of targets) {
       this.events.emit("changed", { type: "updated", conversation: this.snapshotConversation(conv) });
     }
@@ -1500,7 +1712,7 @@ ${new Error("trace").stack}`
         delete conv.pinOrder;
       }
     });
-    await this.save();
+    await this.save(...targets.map((c) => c.id));
     for (const conv of targets) {
       this.events.emit("changed", { type: "updated", conversation: this.snapshotConversation(conv) });
     }
@@ -1515,6 +1727,10 @@ ${new Error("trace").stack}`
   async delete(id) {
     await this.load();
     const existed = this.conversations.delete(id);
+    this.dirty.delete(id);
+    const path = this.written.get(id);
+    this.written.delete(id);
+    if (path) this.removed.add(path);
     await this.save();
     if (existed) {
       this.events.emit("changed", { type: "deleted", id });
@@ -1607,7 +1823,7 @@ function onTurnFinished(listener) {
 }
 
 // ../server/src/services/claude-transcript-sync.ts
-import { readdir, access, readFile as readFile5 } from "fs/promises";
+import { readdir as readdir2, access, readFile as readFile5 } from "fs/promises";
 import { watch } from "fs";
 import { homedir } from "os";
 import { join as join6 } from "path";
@@ -1616,7 +1832,7 @@ var DEFAULT_TITLES = /* @__PURE__ */ new Set(["", "New conversation", "Nouvelle
 async function findClaudeSessionFile(sessionId) {
   let entries;
   try {
-    entries = await readdir(PROJECTS_DIR);
+    entries = await readdir2(PROJECTS_DIR);
   } catch {
     return null;
   }
@@ -1797,7 +2013,7 @@ async function startClaudeTranscriptWatcher() {
   started = true;
   let topLevel;
   try {
-    topLevel = await readdir(PROJECTS_DIR);
+    topLevel = await readdir2(PROJECTS_DIR);
   } catch {
     return;
   }
@@ -1964,14 +2180,27 @@ function getJwtSecret() {
   if (!jwtSecret) throw new Error("JWT secret not yet generated");
   return jwtSecret;
 }
-async function signJwt() {
+async function signJwt(opts = {}) {
   const secret = getJwtSecret();
-  return new SignJWT({ sub: "app" }).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(env.JWT_TTL).sign(secret);
+  return new SignJWT(opts.mcpClientId ? { sub: "app", mcp: opts.mcpClientId } : { sub: "app" }).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(opts.ttl ?? env.JWT_TTL).sign(secret);
+}
+var mcpClientCheck = null;
+function setMcpClientCheck(check) {
+  mcpClientCheck = check;
 }
-async function verifyJwt(token) {
+async function verifyJwt(token, opts = {}) {
   const secret = getJwtSecret();
   const { payload } = await jwtVerify(token, secret);
-  return { exp: payload.exp, iat: payload.iat };
+  const result = { exp: payload.exp, iat: payload.iat };
+  if (payload["mcp"] !== void 0) {
+    if (!opts.allowMcp) throw new Error("MCP client token not allowed here");
+    const clientId = payload["mcp"];
+    if (typeof clientId !== "string" || !mcpClientCheck || !await mcpClientCheck(clientId)) {
+      throw new Error("MCP client is no longer paired");
+    }
+    result.mcpClientId = clientId;
+  }
+  return result;
 }
 
 // ../server/src/services/live-pty.ts
@@ -2256,18 +2485,45 @@ function formatExchange(messages, from) {
 }
 function fullInstructions() {
   return [
-    "Tu relis le travail d'un autre agent, dans la m\xEAme conversation. Tu ne modifies",
-    "rien : ni le code, ni la carte kanban, que tu peux lire mais pas d\xE9placer ni",
-    "commenter. Tu ne d\xE9l\xE8gues pas \xE0 un sous-agent.",
+    "Tu es le compagnon de relecture de cette conversation. Un autre agent y",
+    "travaille pour une personne qui suit l'\xE9change. Ton r\xF4le : v\xE9rifier que ce",
+    "qu'il livre est correct et complet par rapport \xE0 ce qui a \xE9t\xE9 demand\xE9, et le",
+    "lui signaler quand ce n'est pas le cas, avant que la personne ne le d\xE9couvre.",
+    "",
+    "Ce que tu \xE9cris entre les bornes arrive dans sa conversation, pr\xE9fix\xE9 par",
+    `${COMPANION_SIGNATURE}, et le relance. Un d\xE9faut que tu laisses passer co\xFBte plus cher`,
+    "qu'une remarque en trop : l'agent v\xE9rifie et \xE9carte en une phrase ce qui est",
+    "faux. Dans le doute, signale-le en disant que tu n'en es pas s\xFBr.",
+    "",
+    "Tu ne modifies rien : ni le code, ni la carte kanban, que tu peux lire mais",
+    "pas d\xE9placer ni commenter. Tu ne d\xE9l\xE8gues pas \xE0 un sous-agent. Si une carte",
+    "kanban est fournie, c'est la demande : v\xE9rifie que le travail la couvre.",
     "",
     "Images : l'\xE9change ne porte que leur chemin, [Image: source: /chemin.png].",
     "Ouvre-le avec ton outil de lecture. Si la lecture \xE9choue, dis-le. N'invente",
     "jamais le contenu d'une image.",
     "",
+    "CE QUE TU CHERCHES",
+    "- La demande : le travail couvre-t-il tout ce qui a \xE9t\xE9 demand\xE9 (message de",
+    "  la personne, carte kanban) ? Rien d'oubli\xE9, rien d'ajout\xE9 hors sujet ?",
+    "- Les r\xE8gles du projet : lis CLAUDE.md, AGENTS.md ou leur \xE9quivalent s'ils",
+    "  existent, et v\xE9rifie que le travail les respecte.",
+    "- La justesse : cas limites, valeurs vides, erreurs non trait\xE9es, chemins que",
+    "  le code rend atteignables sans les g\xE9rer.",
+    "- Les r\xE9gressions et effets de bord : les appelants du code modifi\xE9, les",
+    "  comportements qui changent sans que la demande le pr\xE9voie.",
+    "- La duplication : une fonction, un composant ou une constante qui existait",
+    "  d\xE9j\xE0 et qu'on a r\xE9\xE9crit \xE0 c\xF4t\xE9.",
+    "- La s\xE9curit\xE9 : entr\xE9es non valid\xE9es, secrets expos\xE9s, contr\xF4les d'acc\xE8s",
+    "  retir\xE9s ou absents.",
+    "- Les tests : un test ajout\xE9 v\xE9rifie-t-il vraiment le comportement ? Un test",
+    "  affaibli, d\xE9sactiv\xE9 ou supprim\xE9 pour passer au vert ?",
+    "- Les affirmations : \xAB les tests passent \xBB, \xAB c'est v\xE9rifi\xE9 \xBB, \xAB rien d'autre",
+    "  n'utilise ce code \xBB. Contr\xF4le-les dans le code ou la sortie montr\xE9e.",
+    "",
     "QUAND PARLER",
     "- Si l'\xE9change te parle ou te pose une question, r\xE9ponds toujours.",
-    "- Sinon, parle seulement si tu as trouv\xE9 un d\xE9faut : r\xE9gression, effet de bord,",
-    "  duplication de code existant, faille de s\xE9curit\xE9, affirmation non v\xE9rifi\xE9e.",
+    "- Sinon, parle si tu as trouv\xE9 un d\xE9faut ou si tu en soup\xE7onnes un.",
     "- Pas d'accus\xE9 de r\xE9ception, de remerciement ni de \xAB rien \xE0 signaler \xBB : chacun",
     "  relance l'agent. Quand il r\xE9pond \xE0 ta remarque, tais-toi, sauf s'il pose une",
     "  question ou si sa r\xE9ponse est fausse.",
@@ -2284,9 +2540,7 @@ function fullInstructions() {
     "  pas pu v\xE9rifier.",
     "- Pas de tests complets, build, typecheck global ni serveur : s'il en faut, dis",
     "  \xE0 l'agent quoi lancer.",
-    "- Ne resignale pas ce qui a d\xE9j\xE0 \xE9t\xE9 signal\xE9, sauf si ce n'est pas trait\xE9.",
-    "",
-    "Ces consignes valent pour toute la session : elles ne te seront pas r\xE9p\xE9t\xE9es."
+    "- Ne resignale pas ce qui a d\xE9j\xE0 \xE9t\xE9 signal\xE9, sauf si ce n'est pas trait\xE9."
   ].join("\n");
 }
 function responseProtocol() {
@@ -2308,7 +2562,7 @@ function responseProtocol() {
 }
 function reminder() {
   return [
-    "Tour suivant \xE0 relire. M\xEAmes r\xE8gles.",
+    "Tour \xE0 relire. Tes consignes sont dans ton contexte syst\xE8me.",
     `Rien \xE0 dire \u2192 ${VERDICT_NOTHING}. Sinon, ton message entre ${RELAY_OPEN} et ${RELAY_CLOSE} \u2014 sans bornes, rien ne part.`,
     "Si l'\xE9change t'adresse quelque chose, tu r\xE9ponds \u2014 jamais " + VERDICT_NOTHING + " dans ce cas.",
     "Mais l'agent qui r\xE9pond \xE0 ta remarque ne te pose pas de question : sans d\xE9faut ni",
@@ -2321,9 +2575,11 @@ function companionDefaultPrompt() {
 function baseLine(baseSha) {
   return `Point de d\xE9part : le travail de la conversation, commits compris, est dans \`git diff ${baseSha}\`.`;
 }
-function buildCompanionPrompt(exchange, isFirstTurn = true, custom, baseSha) {
+function companionInstructions(custom) {
   const customInstructions = custom?.trim();
-  const instructions = isFirstTurn ? [
+  return [
+    "## Tes consignes de compagnon de relecture",
+    "",
     fullInstructions(),
     ...customInstructions ? [
       "",
@@ -2334,9 +2590,11 @@ function buildCompanionPrompt(exchange, isFirstTurn = true, custom, baseSha) {
     // Le protocole, lui, s'ajoute TOUJOURS : c'est par lui que Runeya lit le
     // verdict. Remplaçable, il rendrait le compagnon illisible.
     responseProtocol()
-  ].join("\n") : reminder();
+  ].join("\n");
+}
+function buildCompanionPrompt(exchange, baseSha) {
   return [
-    instructions,
+    reminder(),
     ...baseSha ? ["", baseLine(baseSha)] : [],
     "",
     "--- Ce que tu n'as pas encore relu de la conversation ---",
@@ -2391,13 +2649,11 @@ async function runCompanionForTurn(conversationId) {
   if (!hasNew) {
     return skip(conversationId, "nothingNew", `rien de neuf \xE0 relire (${messageCount} messages)`);
   }
-  const { startCliSession } = await import("./chat-X3X527EX.js");
+  const { startCliSession } = await import("./chat-LPML22J5.js");
   const companionConv = await ensureCompanionConversation(conv);
-  const isFirstTurn = (companionConv.messages?.length ?? 0) === 0;
   const exchange = formatExchange(conv.messages, from);
-  const { prompt: customPrompt } = await companionSettings();
   const baseSha = await ensureCompanionBase(conv);
-  const prompt = buildCompanionPrompt(exchange, isFirstTurn, customPrompt, baseSha);
+  const prompt = buildCompanionPrompt(exchange, baseSha);
   const jwt = await signJwt();
   const environmentId = await activeEnvironmentOf(conv);
   const agentId = companionAgentId(
@@ -2412,7 +2668,7 @@ async function runCompanionForTurn(conversationId) {
         conv.companionRunner ?? conv.runner,
         companionConv.id,
         prompt,
-        { jwt, environmentId, agentId }
+        { jwt, environmentId, agentId, model: conv.companionModel, effort: conv.companionEffort }
       );
       await done;
     } catch (err) {
@@ -2512,7 +2768,7 @@ async function deliverToMainConversation(conv, message) {
 async function attemptDelivery(conv, message) {
   if (await writeToLivePty(conv.id, message)) return "pty";
   try {
-    const { startCliSession } = await import("./chat-X3X527EX.js");
+    const { startCliSession } = await import("./chat-LPML22J5.js");
     await startCliSession(conv.runner, conv.id, message, { jwt: await signJwt() });
     return "headless";
   } catch (err) {
@@ -2533,9 +2789,19 @@ async function writeToLivePty(conversationId, message) {
     return false;
   }
 }
+function companionCreateDefaults(settings, convRunner) {
+  const modelApplies = !!settings.runner || convRunner !== "codex";
+  return {
+    ...settings.enabledByDefault ? { companionEnabled: true } : {},
+    ...settings.runner ? { companionRunner: settings.runner } : {},
+    ...settings.model && modelApplies ? { companionModel: settings.model } : {},
+    // Les deux runners comprennent les mêmes niveaux : l'effort vaut pour tous.
+    ...settings.effort ? { companionEffort: settings.effort } : {}
+  };
+}
 async function companionSettings() {
   try {
-    const { settingsManager } = await import("./settings-manager-32SVMAFN.js");
+    const { settingsManager } = await import("./settings-manager-XPLBO35P.js");
     const settings = await settingsManager.getSettings();
     return settings.companion ?? { enabledByDefault: false };
   } catch {
@@ -2680,6 +2946,7 @@ export {
   generateJwtSecret,
   getJwtSecretGeneratedAt,
   signJwt,
+  setMcpClientCheck,
   verifyJwt,
   ensureDataGitignore,
   conversationSectionStore,
@@ -2687,6 +2954,7 @@ export {
   projectPathStore,
   LocalProjectRefusedError,
   projectStore,
+  CONVERSATIONS_DIRNAME,
   conversationStore,
   resolveWorkspaceCwd,
   resolveAgentCwd,
@@ -2715,6 +2983,7 @@ export {
   reviewWindow,
   formatExchange,
   companionDefaultPrompt,
+  companionInstructions,
   buildCompanionPrompt,
   COMPANION_SIGNATURE,
   buildRelaunchMessage,
@@ -2730,6 +2999,7 @@ export {
   lastCompanionDelivery,
   forgetDelivery,
   deliverToMainConversation,
+  companionCreateDefaults,
   companionSettings,
   answerOfTurn,
   runCompanionNow,
@@ -2737,4 +3007,4 @@ export {
   headCommit,
   initCompanion
 };
-//# sourceMappingURL=chunk-NSS47H26.js.map
+//# sourceMappingURL=chunk-UD42LACH.js.map