openfox 2.0.133 → 2.0.134

package/dist/{chunk-HXHPKGJE.js → chunk-J5HOUEPE.js}

@@ -6,11 +6,12 @@ import {
 import {
   getGateConfig,
   isTaskConflictError,
-  isTaskGateError
-} from "./chunk-FEIRWXLX.js";
+  isTaskGateError,
+  serverT
+} from "./chunk-OZWHRBDY.js";
 import {
   getSessionDisabledServers
-} from "./chunk-TACWRDDC.js";
+} from "./chunk-QDARWVQ2.js";
 import {
   TurnMetrics,
   clearLLMFailure,
@@ -41,7 +42,7 @@ import {
   spawnShellProcess,
   startProcessCommand,
   stopProcess
-} from "./chunk-MQMPIXON.js";
+} from "./chunk-5UMXFLET.js";
 import {
   getMaxPerSession,
   getSessionProcessCount,
@@ -59,12 +60,12 @@ import {
   getEnabledSkillMetadata,
   isSkillEnabled,
   loadAllSkills
-} from "./chunk-BKMWZTNO.js";
+} from "./chunk-DWA4IE65.js";
 import {
   COMPACTION_PROMPT,
   buildBasePrompt,
   computeEffectiveTools
-} from "./chunk-7JVBDBXE.js";
+} from "./chunk-7QMWYNVF.js";
 import {
   AskUserInterrupt,
   askUserTool
@@ -76,12 +77,12 @@ import {
   registerPathConfirmation,
   requestPathAccess,
   resolveRelativeTraversals
-} from "./chunk-Y6ZGHOKM.js";
+} from "./chunk-YLVOU7T7.js";
 import {
   getCurrentContextWindowId,
   getCurrentWindowMessageOptions,
   getEventStore
-} from "./chunk-FGNJMKDV.js";
+} from "./chunk-CSYOWFPU.js";
 import {
   buildContextMessagesFromEventHistory,
   foldContextState,
@@ -91,13 +92,13 @@ import {
   handleToolResult,
   reorderToolMessages,
   stripOrphanedToolCalls
-} from "./chunk-M5T4RDPJ.js";
+} from "./chunk-MEEUXRFL.js";
 import {
   findAgentById,
   getRuntimeConfig,
   getSubAgents,
   loadAllAgentsDefault
-} from "./chunk-ELYHHEYL.js";
+} from "./chunk-ORCQ3EXQ.js";
 import {
   createChatDoneMessage,
   createChatLLMRetryFailedMessage,
@@ -107,7 +108,7 @@ import {
   createChatPathConfirmationMessage,
   createChatStatsMessage,
   createQueueStateMessage
-} from "./chunk-P57IBMK4.js";
+} from "./chunk-AATMPL7S.js";
 import {
   getModelProfile,
   modelSupportsVision
@@ -127,7 +128,7 @@ import {
   SETTINGS_KEYS,
   getSetting,
   setSetting
-} from "./chunk-LQKXJPKP.js";
+} from "./chunk-CTWZPN7G.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -151,7 +152,7 @@ async function requestUserConfirmation(context, toolLabel, desc) {
   if (context.dangerLevel === "dangerous") return Promise.resolve(true);
   if (toolLabel === "workspace" || toolLabel === "command") {
     try {
-      const { getSetting: getSetting2, SETTINGS_KEYS: SETTINGS_KEYS2 } = await import("./settings-MDCRNQBY.js");
+      const { getSetting: getSetting2, SETTINGS_KEYS: SETTINGS_KEYS2 } = await import("./settings-ZJPM6PQV.js");
       if (getSetting2(SETTINGS_KEYS2.CONFIRM_ON_WORKSPACE_ACTIONS) !== "true") {
         return Promise.resolve(true);
       }
@@ -194,7 +195,13 @@ function validateAction(action, allowed, startTime) {
   if (!action || !allowed.includes(action)) {
     return {
       success: false,
-      error: `Invalid action: ${action}. Must be one of: ${allowed.join(", ")}`,
+      error: serverT(
+        {
+          en: "Invalid action: {{action}}. Must be one of: {{allowed}}",
+          fr: "Action invalide : {{action}}. Doit \xEAtre l\u2019une des actions suivantes : {{allowed}}"
+        },
+        { action: action ?? "", allowed: allowed.join(", ") }
+      ),
       durationMs: Date.now() - startTime,
       truncated: false
     };
@@ -205,7 +212,13 @@ function checkActionPermission(action, permittedActions, startTime) {
   if (action && permittedActions && permittedActions.length > 0 && !permittedActions.includes(action)) {
     return {
       success: false,
-      error: `Action '${action}' not allowed. Available: ${permittedActions.join(", ")}`,
+      error: serverT(
+        {
+          en: "Action '{{action}}' not allowed. Available: {{available}}",
+          fr: "Action \xAB {{action}} \xBB non autoris\xE9e. Disponibles : {{available}}"
+        },
+        { action: action ?? "", available: permittedActions.join(", ") }
+      ),
       durationMs: Date.now() - startTime,
       truncated: false
     };
@@ -268,7 +281,10 @@ function createTool(name, definition, handler2) {
         }
         return {
           success: false,
-          error: error instanceof Error ? error.message : "Unknown error in tool execution",
+          error: error instanceof Error ? error.message : serverT({
+            en: "Unknown error in tool execution",
+            fr: "Erreur inconnue lors de l\u2019ex\xE9cution de l\u2019outil"
+          }),
           durationMs: Date.now() - startTime,
           truncated: false
         };
@@ -607,16 +623,30 @@ var readFileTool = createTool(
       }
       if (stats.size > OUTPUT_LIMITS.read_file.maxFileBytes) {
         return helpers.error(
-          `File size (${stats.size} bytes) exceeds maximum file size (20MB). Use shell command to process large files.`
+          serverT(
+            {
+              en: "File size ({{size}} bytes) exceeds maximum file size (20MB). Use shell command to process large files.",
+              fr: "La taille du fichier ({{size}} octets) d\xE9passe la taille maximale (20 Mo). Utilisez une commande shell pour traiter les fichiers volumineux."
+            },
+            { size: stats.size }
+          )
         );
       }
       if (stats.size > OUTPUT_LIMITS.read_file.maxImageBytes) {
         return helpers.error(
-          `File size (${stats.size} bytes) exceeds image size limit (2MB). Use shell command to process large files.`
+          serverT(
+            {
+              en: "File size ({{size}} bytes) exceeds image size limit (2MB). Use shell command to process large files.",
+              fr: "La taille du fichier ({{size}} octets) d\xE9passe la limite pour les images (2 Mo). Utilisez une commande shell pour traiter les fichiers volumineux."
+            },
+            { size: stats.size }
+          )
         );
       }
     } catch {
-      return helpers.error(`File not found: ${args.path}`);
+      return helpers.error(
+        serverT({ en: "File not found: {{path}}", fr: "Fichier introuvable : {{path}}" }, { path: args.path })
+      );
     }
     const rawBuffer = await readFile2(fullPath);
     const mimeType = await detectImageType(rawBuffer, args.path);
@@ -632,15 +662,22 @@ var readFileTool = createTool(
           relative2(context.workdir, fullPath)
         );
       }
-      return helpers.success(`[Image: ${args.path} (${mimeType}, ${rawBuffer.length} bytes)]`, false, {
-        metadata: {
-          mimeType,
-          size: rawBuffer.length,
-          base64Data,
-          dataUrl,
-          path: fullPath
+      return helpers.success(
+        serverT(
+          { en: "[Image: {{path}} ({{mime}}, {{size}} bytes)]", fr: "[Image : {{path}} ({{mime}}, {{size}} octets)]" },
+          { path: args.path, mime: mimeType, size: rawBuffer.length }
+        ),
+        false,
+        {
+          metadata: {
+            mimeType,
+            size: rawBuffer.length,
+            base64Data,
+            dataUrl,
+            path: fullPath
+          }
         }
-      });
+      );
     }
     if (isPdfBuffer(rawBuffer)) {
       try {
@@ -795,7 +832,9 @@ var writeFileTool = createTool(
     const readFiles = context.sessionManager.getReadFiles(context.sessionId);
     const validation = await validateFileForWrite(fullPath, readFiles, context.workdir);
     if (!validation.valid) {
-      return helpers.error(validation.error?.message ?? "File validation failed");
+      return helpers.error(
+        validation.error?.message ?? serverT({ en: "File validation failed", fr: "\xC9chec de la validation du fichier" })
+      );
     }
     const dir = dirname(fullPath);
     await mkdir(dir, { recursive: true });
@@ -804,7 +843,13 @@ var writeFileTool = createTool(
     await writeFile(fullPath, encoded);
     const lineCount = args.content.split("\n").length;
     const byteCount = encoded.length;
-    let output = `Successfully wrote ${lineCount} lines (${byteCount} bytes) to ${args.path}`;
+    let output = serverT(
+      {
+        en: "Successfully wrote {{lines}} lines ({{bytes}} bytes) to {{path}}",
+        fr: "{{lines}} lignes ({{bytes}} octets) \xE9crites avec succ\xE8s dans {{path}}"
+      },
+      { lines: lineCount, bytes: byteCount, path: args.path }
+    );
     let diagnostics = [];
     if (context.lspManager) {
       diagnostics = await context.lspManager.notifyFileChange(fullPath, args.content);
@@ -992,13 +1037,17 @@ var editFileTool = createTool(
       const readFiles = context.sessionManager.getReadFiles(context.sessionId);
       const validation = await validateFileForWrite(fullPath, readFiles, context.workdir);
       if (!validation.valid) {
-        return helpers.error(validation.error?.message ?? "File validation failed");
+        return helpers.error(
+          validation.error?.message ?? serverT({ en: "File validation failed", fr: "\xC9chec de la validation du fichier" })
+        );
       }
       let rawBuffer;
       try {
         rawBuffer = await readFile3(fullPath);
       } catch {
-        return helpers.error(`File not found: ${args.path}`);
+        return helpers.error(
+          serverT({ en: "File not found: {{path}}", fr: "Fichier introuvable : {{path}}" }, { path: args.path })
+        );
       }
       const { encoding, bomSize } = detectEncoding(rawBuffer);
       const content = decodeContent(rawBuffer, encoding);
@@ -1009,17 +1058,24 @@ var editFileTool = createTool(
       if (occurrences === 0) {
         const preview = args.old_string.length > 100 ? args.old_string.slice(0, 100) + "..." : args.old_string;
         return helpers.error(
-          `old_string not found in file.
-
-Searched for:
-${preview}
-
-Make sure whitespace and indentation match exactly.`
+          serverT(
+            {
+              en: "old_string not found in file.\n\nSearched for:\n{{preview}}\n\nMake sure whitespace and indentation match exactly.",
+              fr: "old_string introuvable dans le fichier.\n\nRecherch\xE9 :\n{{preview}}\n\nV\xE9rifiez que les espaces et l\u2019indentation correspondent exactement."
+            },
+            { preview }
+          )
         );
       }
       if (occurrences > 1 && !replaceAll) {
         return helpers.error(
-          `Found ${occurrences} matches for old_string. Use replace_all: true to replace all, or provide more context to make the match unique.`
+          serverT(
+            {
+              en: "Found {{count}} matches for old_string. Use replace_all: true to replace all, or provide more context to make the match unique.",
+              fr: "{{count}} correspondances trouv\xE9es pour old_string. Utilisez replace_all : true pour tout remplacer, ou fournissez plus de contexte pour rendre la correspondance unique."
+            },
+            { count: occurrences }
+          )
         );
       }
       const contextResult = extractEditContext(
@@ -1055,7 +1111,12 @@ Make sure whitespace and indentation match exactly.`
       } else {
         const index = normalizedContent.indexOf(normalizedOldString);
         if (index === -1) {
-          return helpers.error("old_string not found in file (unexpected)");
+          return helpers.error(
+            serverT({
+              en: "old_string not found in file (unexpected)",
+              fr: "old_string introuvable dans le fichier (inattendu)"
+            })
+          );
         }
         replacedContent = normalizedContent.slice(0, index) + normalizedNewString + normalizedContent.slice(index + normalizedOldString.length);
       }
@@ -1065,7 +1126,13 @@ Make sure whitespace and indentation match exactly.`
       );
       const encoded = encodeContent(restoredContent, encoding, bomSize > 0);
       await writeFile2(fullPath, encoded);
-      let output = `Successfully replaced ${replaceAll ? occurrences : 1} occurrence(s) in ${args.path}`;
+      let output = serverT(
+        {
+          en: "Successfully replaced {{count}} occurrence(s) in {{path}}",
+          fr: "{{count}} occurrence(s) remplac\xE9e(s) avec succ\xE8s dans {{path}}"
+        },
+        { count: replaceAll ? occurrences : 1, path: args.path }
+      );
       let diagnostics = [];
       if (context.lspManager) {
         diagnostics = await context.lspManager.notifyFileChange(fullPath, restoredContent);
@@ -1204,16 +1271,31 @@ var runCommandTool = createTool(
     const timeout = args.timeout ?? 12e4;
     if (hasBackgroundAmpersand(args.command)) {
       return helpers.error(
-        `Use background_process tool (action: "start") for background/long-running commands instead of '&'. See the tool description for details.`
+        serverT({
+          en: `Use background_process tool (action: "start") for background/long-running commands instead of '&'. See the tool description for details.`,
+          fr: "Utilisez l\u2019outil background_process (action : \xAB start \xBB) pour les commandes d\u2019arri\xE8re-plan ou de longue dur\xE9e au lieu de \xAB & \xBB. Consultez la description de l\u2019outil pour plus de d\xE9tails."
+        })
       );
     }
     const mutationMatch = detectGitMutation(args.command);
     if (mutationMatch) {
-      const desc = `Command "${args.command}" modifies Git state (${mutationMatch}). Allow this Git operation?`;
+      const desc = serverT(
+        {
+          en: 'Command "{{cmd}}" modifies Git state ({{mutation}}). Allow this Git operation?',
+          fr: "La commande \xAB {{cmd}} \xBB modifie l\u2019\xE9tat Git ({{mutation}}). Autoriser cette op\xE9ration Git ?"
+        },
+        { cmd: args.command, mutation: mutationMatch }
+      );
       const approved = await requestUserConfirmation(context, "command", desc);
       if (!approved) {
         return helpers.error(
-          `User denied: "${mutationMatch}" modifies Git state. Use the workspace tool to switch workspaces or branches.`
+          serverT(
+            {
+              en: 'User denied: "{{mutation}}" modifies Git state. Use the workspace tool to switch workspaces or branches.',
+              fr: "Refus\xE9 par l\u2019utilisateur : \xAB {{mutation}} \xBB modifie l\u2019\xE9tat Git. Utilisez l\u2019outil workspace pour changer de workspace ou de branche."
+            },
+            { mutation: mutationMatch }
+          )
         );
       }
     }
@@ -1271,7 +1353,12 @@ ${result.stderr}`;
     const wasInterrupted = output.includes("[interrupted by user]");
     return helpers.success(output, truncated, {
       success: result.exitCode === 0,
-      ...result.exitCode !== 0 && !wasInterrupted ? { error: `Command exited with code ${result.exitCode}` } : {}
+      ...result.exitCode !== 0 && !wasInterrupted ? {
+        error: serverT(
+          { en: "Command exited with code {{code}}", fr: "La commande s\u2019est termin\xE9e avec le code {{code}}" },
+          { code: result.exitCode }
+        )
+      } : {}
     });
   }
 );
@@ -1412,10 +1499,14 @@ function normalizeId(id) {
   return String(id);
 }
 function requireKeyAndId(args, helpers, entries) {
-  if (!args.key) return helpers.error("Missing required field: key");
-  if (normalizeId(args.id) === void 0) return helpers.error("Missing required field: id");
+  if (!args.key) return helpers.error(serverT({ en: "Missing required field: key", fr: "Champ requis manquant : key" }));
+  if (normalizeId(args.id) === void 0)
+    return helpers.error(serverT({ en: "Missing required field: id", fr: "Champ requis manquant : id" }));
   const current = entries[args.key];
-  if (!current) return helpers.error(`Key "${args.key}" not found.`);
+  if (!current)
+    return helpers.error(
+      serverT({ en: 'Key "{{key}}" not found.', fr: "Cl\xE9 \xAB {{key}} \xBB introuvable." }, { key: args.key ?? "" })
+    );
   return current;
 }
 var sessionMetadataTool = createTool(
@@ -1466,18 +1557,26 @@ var sessionMetadataTool = createTool(
     const entries = session.metadataEntries ?? {};
     if (args.action === "list") {
       const keys = Object.keys(entries);
-      if (keys.length === 0) return helpers.success("No metadata keys defined.");
+      if (keys.length === 0)
+        return helpers.success(serverT({ en: "No metadata keys defined.", fr: "Aucune cl\xE9 de m\xE9tadonn\xE9es d\xE9finie." }));
       return helpers.success(
         `Metadata keys:
 ${keys.map((k) => `- ${k} (${entries[k]?.length ?? 0} items)`).join("\n")}`
       );
     }
     if (args.action === "schema") {
-      if (!args.key) return helpers.error("Missing required field: key");
+      if (!args.key)
+        return helpers.error(serverT({ en: "Missing required field: key", fr: "Champ requis manquant : key" }));
       const schema = SCHEMAS[args.key];
       if (!schema)
         return helpers.success(
-          `No schema defined for key "${args.key}". Items have id, description, and status fields.`
+          serverT(
+            {
+              en: 'No schema defined for key "{{key}}". Items have id, description, and status fields.',
+              fr: "Aucun sch\xE9ma d\xE9fini pour la cl\xE9 \xAB {{key}} \xBB. Les \xE9l\xE9ments ont des champs id, description et status."
+            },
+            { key: args.key ?? "" }
+          )
         );
       return helpers.success(
         `Key: ${args.key}
@@ -1487,14 +1586,25 @@ ${Object.entries(schema.fields).map(([f, t]) => `  ${f}: ${t}`).join("\n")}`
       );
     }
     if (args.action === "get") {
-      if (!args.key) return helpers.error("Missing required field: key");
+      if (!args.key)
+        return helpers.error(serverT({ en: "Missing required field: key", fr: "Champ requis manquant : key" }));
       const keyEntries = entries[args.key];
-      if (!keyEntries || keyEntries.length === 0) return helpers.success(`No entries for key "${args.key}".`);
+      if (!keyEntries || keyEntries.length === 0)
+        return helpers.success(
+          serverT(
+            { en: 'No entries for key "{{key}}".', fr: "Aucune entr\xE9e pour la cl\xE9 \xAB {{key}} \xBB." },
+            { key: args.key ?? "" }
+          )
+        );
       return helpers.success(JSON.stringify(keyEntries, null, 2));
     }
     if (args.action === "add") {
-      if (!args.key) return helpers.error("Missing required field: key");
-      if (!args.description) return helpers.error("Missing required field: description");
+      if (!args.key)
+        return helpers.error(serverT({ en: "Missing required field: key", fr: "Champ requis manquant : key" }));
+      if (!args.description)
+        return helpers.error(
+          serverT({ en: "Missing required field: description", fr: "Champ requis manquant : description" })
+        );
       const current = entries[args.key] ?? [];
       const newEntry = {
         id: normalizeId(args.id) ?? (current.length + 1).toString(),
@@ -1503,14 +1613,28 @@ ${Object.entries(schema.fields).map(([f, t]) => `  ${f}: ${t}`).join("\n")}`
       };
       const updated = [...current, newEntry];
       context.sessionManager.setMetadataEntries(context.sessionId, args.key, updated);
-      return helpers.success(`Added item "${newEntry.id}" to "${args.key}". Total: ${updated.length} items.`);
+      return helpers.success(
+        serverT(
+          {
+            en: 'Added item "{{id}}" to "{{key}}". Total: {{count}} items.',
+            fr: "\xC9l\xE9ment \xAB {{id}} \xBB ajout\xE9 \xE0 \xAB {{key}} \xBB. Total : {{count}} \xE9l\xE9ments."
+          },
+          { id: newEntry.id, key: args.key ?? "", count: updated.length }
+        )
+      );
     }
     if (args.action === "update") {
       const current = requireKeyAndId(args, helpers, entries);
       if (!Array.isArray(current)) return current;
       const id = normalizeId(args.id);
       const idx = current.findIndex((e) => e.id === id);
-      if (idx === -1) return helpers.error(`Item "${id}" not found in "${args.key}".`);
+      if (idx === -1)
+        return helpers.error(
+          serverT(
+            { en: 'Item "{{id}}" not found in "{{key}}".', fr: "\xC9l\xE9ment \xAB {{id}} \xBB introuvable dans \xAB {{key}} \xBB." },
+            { id, key: args.key ?? "" }
+          )
+        );
       const updated = current.map(
         (e, i) => i === idx ? {
           ...e,
@@ -1519,18 +1643,37 @@ ${Object.entries(schema.fields).map(([f, t]) => `  ${f}: ${t}`).join("\n")}`
         } : e
       );
       context.sessionManager.setMetadataEntries(context.sessionId, args.key, updated);
-      return helpers.success(`Updated item "${id}" in "${args.key}".`);
+      return helpers.success(
+        serverT(
+          { en: 'Updated item "{{id}}" in "{{key}}".', fr: "\xC9l\xE9ment \xAB {{id}} \xBB mis \xE0 jour dans \xAB {{key}} \xBB." },
+          { id, key: args.key ?? "" }
+        )
+      );
     }
     if (args.action === "remove") {
       const current = requireKeyAndId(args, helpers, entries);
       if (!Array.isArray(current)) return current;
       const id = normalizeId(args.id);
       const updated = current.filter((e) => e.id !== id);
-      if (updated.length === current.length) return helpers.error(`Item "${id}" not found in "${args.key}".`);
+      if (updated.length === current.length)
+        return helpers.error(
+          serverT(
+            { en: 'Item "{{id}}" not found in "{{key}}".', fr: "\xC9l\xE9ment \xAB {{id}} \xBB introuvable dans \xAB {{key}} \xBB." },
+            { id, key: args.key ?? "" }
+          )
+        );
       context.sessionManager.setMetadataEntries(context.sessionId, args.key, updated);
-      return helpers.success(`Removed item "${id}" from "${args.key}". ${updated.length} items remaining.`);
+      return helpers.success(
+        serverT(
+          {
+            en: 'Removed item "{{id}}" from "{{key}}". {{count}} items remaining.',
+            fr: "\xC9l\xE9ment \xAB {{id}} \xBB supprim\xE9 de \xAB {{key}} \xBB. {{count}} \xE9l\xE9ments restants."
+          },
+          { id, key: args.key ?? "", count: updated.length }
+        )
+      );
     }
-    return helpers.error("Unexpected error");
+    return helpers.error(serverT({ en: "Unexpected error", fr: "Erreur inattendue" }));
   }
 );
 
@@ -1623,7 +1766,12 @@ function createToolProgressHandler(append, messageId, callId, _sessionId) {
 
 // src/server/chat/execute-tools.ts
 import stripAnsi2 from "strip-ansi";
-var INTERRUPTED_ERROR = "Tool execution was interrupted by user";
+function interruptedError() {
+  return serverT({
+    en: "Tool execution was interrupted by user",
+    fr: "L\u2019ex\xE9cution de l\u2019outil a \xE9t\xE9 interrompue par l\u2019utilisateur"
+  });
+}
 function extractSubAgentPrompt(args) {
   return args["prompt"] || args["query"] || args["task"] || "";
 }
@@ -1642,7 +1790,7 @@ async function transformSubAgentAliases(toolCalls, toolRegistry, projectDir) {
 function createInterruptedResult(startTime) {
   return {
     success: false,
-    error: INTERRUPTED_ERROR,
+    error: interruptedError(),
     durationMs: startTime ? Date.now() - startTime : 0,
     truncated: false
   };
@@ -1663,7 +1811,13 @@ async function executeTools(assistantMsgId, toolCalls, ctx, append) {
     if (error instanceof PathAccessDeniedError) {
       return {
         success: false,
-        error: `User denied access to ${error.paths.join(", ")}. If you need this file, explain why and ask for permission.`,
+        error: serverT(
+          {
+            en: "User denied access to {{paths}}. If you need this file, explain why and ask for permission.",
+            fr: "Acc\xE8s refus\xE9 par l\u2019utilisateur : {{paths}}. Si vous avez besoin de ce fichier, expliquez pourquoi et demandez l\u2019autorisation."
+          },
+          { paths: error.paths.join(", ") }
+        ),
         durationMs: Date.now() - startTime,
         truncated: false
       };
@@ -1676,7 +1830,15 @@ async function executeTools(assistantMsgId, toolCalls, ctx, append) {
       const { awaitAnswer } = await import("./ask-UBIRH3SO.js");
       const answerPromise = awaitAnswer(error.callId);
       if (!answerPromise) {
-        throw new Error(`No pending question found for callId: ${error.callId}`);
+        throw new Error(
+          serverT(
+            {
+              en: "No pending question found for callId: {{id}}",
+              fr: "Aucune question en attente trouv\xE9e pour callId : {{id}}"
+            },
+            { id: error.callId }
+          )
+        );
       }
       const answer = await answerPromise;
       return {
@@ -1698,7 +1860,7 @@ async function executeTools(assistantMsgId, toolCalls, ctx, append) {
       return {
         toolCall,
         toolResult: toolResult2,
-        content: `Error: ${INTERRUPTED_ERROR}`,
+        content: serverT({ en: "Error: {{message}}", fr: "Erreur : {{message}}" }, { message: interruptedError() }),
         index
       };
     }
@@ -1709,7 +1871,13 @@ async function executeTools(assistantMsgId, toolCalls, ctx, append) {
       } else {
         const toolResult2 = {
           success: false,
-          error: `Failed to parse tool call arguments: ${toolCall.parseError}. Please ensure your JSON function call arguments are valid.`,
+          error: serverT(
+            {
+              en: "Failed to parse tool call arguments: {{error}}. Please ensure your JSON function call arguments are valid.",
+              fr: "\xC9chec de l\u2019analyse des arguments de l\u2019appel d\u2019outil : {{error}}. Assurez-vous que vos arguments JSON d\u2019appel de fonction sont valides."
+            },
+            { error: toolCall.parseError ?? "" }
+          ),
           durationMs: 0,
           truncated: false
         };
@@ -1717,7 +1885,10 @@ async function executeTools(assistantMsgId, toolCalls, ctx, append) {
         return {
           toolCall,
           toolResult: toolResult2,
-          content: `Error: ${toolResult2.error}`,
+          content: serverT(
+            { en: "Error: {{message}}", fr: "Erreur : {{message}}" },
+            { message: toolResult2.error ?? "" }
+          ),
           index
         };
       }
@@ -1760,9 +1931,10 @@ async function executeTools(assistantMsgId, toolCalls, ctx, append) {
       stepDoneCalled = true;
     }
     const rawContent = stripAnsi2(
-      toolResult.success ? toolResult.output ?? "Success" : toolResult.output ? `${toolResult.output}
-
-Error: ${toolResult.error}` : `Error: ${toolResult.error}`
+      toolResult.success ? toolResult.output ?? serverT({ en: "Success", fr: "Succ\xE8s" }) : toolResult.output ? serverT(
+        { en: "{{output}}\n\nError: {{error}}", fr: "{{output}}\n\nErreur : {{error}}" },
+        { output: toolResult.output, error: toolResult.error ?? "" }
+      ) : serverT({ en: "Error: {{error}}", fr: "Erreur : {{error}}" }, { error: toolResult.error ?? "" })
     );
     const { clean: content, corrupted } = sanitizeUtf8(rawContent);
     if (corrupted) {
@@ -2082,7 +2254,7 @@ ${CONTINUE_PROMPT}` : CONTINUE_PROMPT;
         return { failed: { error: attemptResult.error } };
       }
       if (!config.subAgentMetadata) {
-        config.onMessage?.(createChatLLMRetryMessage(decision.attempt, decision.delayMs));
+        config.onMessage?.(createChatLLMRetryMessage(decision.attempt, decision.delayMs, attemptResult.error));
       }
       const waitResult = await sleepThroughRetryBackoff(decision.delayMs, sessionId, signal);
       if (waitResult === "aborted") throw new Error("Aborted");
@@ -2094,7 +2266,16 @@ ${CONTINUE_PROMPT}` : CONTINUE_PROMPT;
       if (!retryLimiter.canRetry()) {
         append({
           type: "chat.error",
-          data: { error: `Auto-retry limit exceeded after ${retryLimiter.maxRetries()} retries`, recoverable: false }
+          data: {
+            error: serverT(
+              {
+                en: "Auto-retry limit exceeded after {{count}} retries",
+                fr: "Limite de relance automatique d\xE9pass\xE9e apr\xE8s {{count}} tentatives"
+              },
+              { count: retryLimiter.maxRetries() }
+            ),
+            recoverable: false
+          }
         });
         append(createChatDoneEvent(assistantMsgId, "error", void 0, agentType));
         throw new Error("Auto-retry limit exceeded");
@@ -2154,7 +2335,7 @@ ${CONTINUE_PROMPT}` : CONTINUE_PROMPT;
     currentMaxTokensOverride = void 0;
     if (!compacting) {
       const contextState = sessionManager.getContextState(sessionId);
-      const { shouldCompact, appendCompactionPrompt } = await import("./compactor-OEJAA2YP.js");
+      const { shouldCompact, appendCompactionPrompt } = await import("./compactor-PD6DQ4NY.js");
       if (shouldCompact(
         contextState.currentTokens,
         contextState.maxTokens,
@@ -2319,7 +2500,13 @@ ${COMPACTION_PROMPT}`,
       if (!summary) {
         append({
           type: "chat.error",
-          data: { error: "Compaction produced empty summary, continuing with full context", recoverable: true }
+          data: {
+            error: serverT({
+              en: "Compaction produced empty summary, continuing with full context",
+              fr: "La compaction a produit un r\xE9sum\xE9 vide, poursuite avec le contexte complet"
+            }),
+            recoverable: true
+          }
         });
         logger.warn("Compaction produced empty summary, continuing", { sessionId });
         compacting = false;
@@ -3187,7 +3374,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-CW6POKUL.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-WWIWD3O7.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -3236,10 +3423,17 @@ ${skill.prompt}`;
 var handler = async (args, context, helpers) => {
   const { skillId } = args;
   if (!skillId) {
-    return helpers.error("Missing required parameter: skillId");
+    return helpers.error(
+      serverT({ en: "Missing required parameter: skillId", fr: "Param\xE8tre requis manquant : skillId" })
+    );
   }
   if (!isSkillEnabled(skillId)) {
-    return helpers.error(`Skill "${skillId}" is not enabled.`);
+    return helpers.error(
+      serverT(
+        { en: 'Skill "{{id}}" is not enabled.', fr: "La comp\xE9tence \xAB {{id}} \xBB n\u2019est pas activ\xE9e." },
+        { id: skillId }
+      )
+    );
   }
   const config = getRuntimeConfig();
   const configDir = getGlobalConfigDir(config.mode ?? "production");
@@ -3247,7 +3441,15 @@ var handler = async (args, context, helpers) => {
   const skill = findSkillById(skillId, allSkills);
   if (!skill) {
     const available = allSkills.map((s) => s.metadata.id).join(", ");
-    return helpers.error(`Skill "${skillId}" not found. Available skills: ${available}`);
+    return helpers.error(
+      serverT(
+        {
+          en: 'Skill "{{id}}" not found. Available skills: {{available}}',
+          fr: "Comp\xE9tence \xAB {{id}} \xBB introuvable. Comp\xE9tences disponibles : {{available}}"
+        },
+        { id: skillId, available }
+      )
+    );
   }
   return helpers.success(formatSkillPrompt(skill));
 };
@@ -3374,7 +3576,9 @@ var webFetchTool = createTool(
     const url = args.url;
     const format = args.format ?? "markdown";
     if (!url.startsWith("http://") && !url.startsWith("https://")) {
-      return helpers.error("URL must start with http:// or https://");
+      return helpers.error(
+        serverT({ en: "URL must start with http:// or https://", fr: "L\u2019URL doit commencer par http:// ou https://" })
+      );
     }
     const timeoutMs = (args.timeout ?? DEFAULT_TIMEOUT_MS / 1e3) * 1e3;
     const signal = buildSignal(timeoutMs, context.signal);
@@ -3386,22 +3590,40 @@ var webFetchTool = createTool(
     const initial = await fetch(url, { signal, headers });
     const response = initial.status === 403 && initial.headers.get("cf-mitigated") === "challenge" ? await fetch(url, { signal, headers: { ...headers, "User-Agent": "openfox" } }) : initial;
     if (!response.ok) {
-      return helpers.error(`Request failed with status code: ${response.status}`);
+      return helpers.error(
+        serverT(
+          {
+            en: "Request failed with status code: {{status}}",
+            fr: "\xC9chec de la requ\xEAte avec le code de statut : {{status}}"
+          },
+          { status: response.status }
+        )
+      );
     }
     const contentLength = response.headers.get("content-length");
     if (contentLength && parseInt(contentLength) > MAX_RESPONSE_SIZE) {
-      return helpers.error("Response too large (exceeds 5MB limit)");
+      return helpers.error(
+        serverT({
+          en: "Response too large (exceeds 5MB limit)",
+          fr: "R\xE9ponse trop volumineuse (d\xE9passe la limite de 5 Mo)"
+        })
+      );
     }
     const arrayBuffer = await response.arrayBuffer();
     if (arrayBuffer.byteLength > MAX_RESPONSE_SIZE) {
-      return helpers.error("Response too large (exceeds 5MB limit)");
+      return helpers.error(
+        serverT({
+          en: "Response too large (exceeds 5MB limit)",
+          fr: "R\xE9ponse trop volumineuse (d\xE9passe la limite de 5 Mo)"
+        })
+      );
     }
     const contentType = response.headers.get("content-type") || "";
     const mime = contentType.split(";")[0]?.trim().toLowerCase() || "";
     const isImage = mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet";
     if (isImage) {
       const base64Data = Buffer.from(arrayBuffer).toString("base64");
-      return helpers.success("Image fetched successfully", false, {
+      return helpers.success(serverT({ en: "Image fetched successfully", fr: "Image r\xE9cup\xE9r\xE9e avec succ\xE8s" }), false, {
         metadata: {
           mimeType: mime,
           base64Data,
@@ -3882,7 +4104,19 @@ var devServerTool = createTool(
     }
     if (!status.config) {
       return helpers.error(
-        'No .openfox/dev.json config found. Create one in the project root:\n\n{\n  "command": "npm run dev",\n  "url": "http://localhost:3000",\n  "hotReload": true,\n  "disableInspect": false\n}\n\n(Worktrees inherit the project root config automatically.)'
+        serverT(
+          {
+            en: "No .openfox/dev.json config found. Create one in the project root:\n\n{{config}}\n\n(Worktrees inherit the project root config automatically.)",
+            fr: "Aucun fichier .openfox/dev.json trouv\xE9. Cr\xE9ez-en un \xE0 la racine du projet :\n\n{{config}}\n\n(Les worktrees h\xE9ritent automatiquement de la configuration du projet.)"
+          },
+          {
+            config: JSON.stringify(
+              { command: "npm run dev", url: "http://localhost:3000", hotReload: true, disableInspect: false },
+              null,
+              2
+            )
+          }
+        )
       );
     }
     return helpers.success(
@@ -3918,7 +4152,7 @@ var stepDoneTool = {
   async execute(_args, _context) {
     return {
       success: true,
-      output: "Step completion signal recorded.",
+      output: serverT({ en: "Step completion signal recorded.", fr: "Signal de fin d\u2019\xE9tape enregistr\xE9." }),
       durationMs: 0,
       truncated: false
     };
@@ -3926,6 +4160,9 @@ var stepDoneTool = {
 };
 
 // src/server/tools/background-process/index.ts
+function processNotFoundError(id) {
+  return serverT({ en: "Process not found: {{id}}", fr: "Processus introuvable : {{id}}" }, { id: id ?? "" });
+}
 var backgroundProcessTool = createTool(
   "background_process",
   {
@@ -3998,17 +4235,28 @@ These processes run independently of agent turns and persist across session comp
         const maxPerSession = getMaxPerSession();
         if (count >= maxPerSession) {
           return helpers.error(
-            `Maximum number of background processes (${maxPerSession}) reached. Stop existing processes before starting new ones.`
+            serverT(
+              {
+                en: "Maximum number of background processes ({{count}}) reached. Stop existing processes before starting new ones.",
+                fr: "Nombre maximal de processus en arri\xE8re-plan ({{count}}) atteint. Arr\xEAtez des processus existants avant d\u2019en d\xE9marrer de nouveaux."
+              },
+              { count: maxPerSession }
+            )
           );
         }
         const name = args.name ?? args.command?.split(" ")[0] ?? "process";
         const process2 = createProcess(sessionId, name, args.command, cwd, args.timeout);
         if (!process2) {
-          return helpers.error(`Failed to create process. Maximum limit may have been reached.`);
+          return helpers.error(
+            serverT({
+              en: "Failed to create process. Maximum limit may have been reached.",
+              fr: "\xC9chec de la cr\xE9ation du processus. La limite maximale a peut-\xEAtre \xE9t\xE9 atteinte."
+            })
+          );
         }
         const pid = startProcessCommand(process2.id, sessionId, args.command, cwd);
         if (!pid) {
-          return helpers.error(`Failed to start process.`);
+          return helpers.error(serverT({ en: "Failed to start process.", fr: "\xC9chec du d\xE9marrage du processus." }));
         }
         return helpers.success(
           JSON.stringify(
@@ -4026,11 +4274,17 @@ These processes run independently of agent turns and persist across session comp
       }
       case "stop": {
         const proc = getProcessStatus(args.processId, sessionId);
-        if (!proc) {
-          return helpers.error(`Process not found: ${args.processId}`);
-        }
+        if (!proc) return helpers.error(processNotFoundError(args.processId));
         if (proc.status !== "running") {
-          return helpers.error(`Process is not running (status: ${proc.status}). Cannot stop.`);
+          return helpers.error(
+            serverT(
+              {
+                en: "Process is not running (status: {{status}}). Cannot stop.",
+                fr: "Le processus n\u2019est pas en cours d\u2019ex\xE9cution (statut : {{status}}). Impossible de l\u2019arr\xEAter."
+              },
+              { status: proc.status }
+            )
+          );
         }
         await stopProcess(args.processId, sessionId);
         return helpers.success(
@@ -4061,9 +4315,7 @@ These processes run independently of agent turns and persist across session comp
       }
       case "status": {
         const proc = getProcessStatus(args.processId, sessionId);
-        if (!proc) {
-          return helpers.error(`Process not found: ${args.processId}`);
-        }
+        if (!proc) return helpers.error(processNotFoundError(args.processId));
         const uptime = proc.startedAt ? Date.now() - proc.startedAt : null;
         return helpers.success(
           JSON.stringify(
@@ -4078,9 +4330,7 @@ These processes run independently of agent turns and persist across session comp
       }
       case "logs": {
         const proc = getProcessStatus(args.processId, sessionId);
-        if (!proc) {
-          return helpers.error(`Process not found: ${args.processId}`);
-        }
+        if (!proc) return helpers.error(processNotFoundError(args.processId));
         const since = args.since ?? 0;
         const maxLines = Math.min(args.maxLines ?? 500, 2e3);
         const { lines, totalLines, nextOffset, hasMore } = getProcessLogs(args.processId, since, maxLines);
@@ -4100,7 +4350,9 @@ These processes run independently of agent turns and persist across session comp
         );
       }
       default:
-        return helpers.error(`Unknown action: ${args.action}`);
+        return helpers.error(
+          serverT({ en: "Unknown action: {{action}}", fr: "Action inconnue : {{action}}" }, { action: args.action })
+        );
     }
   }
 );
@@ -4200,13 +4452,18 @@ var mcpConfigTool = createTool(
     if (actionError) return actionError;
     if (args.action === "bootstrap") {
       if (!mcpBootstrapForTools) {
-        return helpers.error("MCP bootstrap is not available for this server");
+        return helpers.error(
+          serverT({
+            en: "MCP bootstrap is not available for this server",
+            fr: "Le bootstrap MCP n\u2019est pas disponible pour ce serveur"
+          })
+        );
       }
       const config = await mcpBootstrapForTools();
       return helpers.success(JSON.stringify(config, null, 2));
     }
     if (!mcpManagerForTools) {
-      return helpers.error("MCP manager not available");
+      return helpers.error(serverT({ en: "MCP manager not available", fr: "Gestionnaire MCP indisponible" }));
     }
     async function persistAndRebuild(updater) {
       const globalConfig = await loadGlobalConfig(mcpConfigMode, mcpConfigPath);
@@ -4214,59 +4471,85 @@ var mcpConfigTool = createTool(
       const updated = updater(mcpServers);
       await saveGlobalConfig(mcpConfigMode, { ...globalConfig, mcpServers: updated }, mcpConfigPath);
     }
-    const APPLY_PROMPT_MESSAGE = "Tool changes are announced automatically.";
+    const APPLY_PROMPT_MESSAGE = serverT({
+      en: "Tool changes are announced automatically.",
+      fr: "Les modifications d\u2019outils sont annonc\xE9es automatiquement."
+    });
     async function notifyContextChanged(sessionId) {
       context.sessionManager.setDynamicContextChanged(sessionId, true);
       mcpNotifyChanged?.(sessionId);
-      const { injectContextDriftReminders } = await import("./dynamic-context-NJZKAZE3.js");
+      const { injectContextDriftReminders } = await import("./dynamic-context-WKEXQCTK.js");
       await injectContextDriftReminders(context.sessionManager, sessionId);
     }
     async function rebuildTools() {
-      const { setMcpTools: setMcpTools2 } = await import("./tools-CW6POKUL.js");
+      const { setMcpTools: setMcpTools2 } = await import("./tools-WWIWD3O7.js");
       const mcpTools = createMcpTools(mcpManagerForTools);
       setMcpTools2(mcpTools);
     }
     if (args.action === "list") {
       const servers = mcpManagerForTools.getAllServers();
       if (servers.length === 0) {
-        return helpers.success("No MCP servers configured.");
+        return helpers.success(serverT({ en: "No MCP servers configured.", fr: "Aucun serveur MCP configur\xE9." }));
       }
-      const { getSessionDisabledServers: getSessionDisabledServers2 } = await import("./session-overrides-OECQYRDK.js");
+      const { getSessionDisabledServers: getSessionDisabledServers2 } = await import("./session-overrides-Y5B4XQPU.js");
       const disabledForSession = new Set(context.sessionId ? getSessionDisabledServers2(context.sessionId) : []);
       const visibleServers = servers.filter((server) => !disabledForSession.has(server.name));
       if (visibleServers.length === 0) {
-        return helpers.success("No MCP servers configured.");
+        return helpers.success(serverT({ en: "No MCP servers configured.", fr: "Aucun serveur MCP configur\xE9." }));
       }
       const lines = [];
       for (const server of visibleServers) {
         const connStr = server.status === "connected" ? "\u25CF" : server.status === "error" ? "\u2717" : "\u25CB";
         const cmdStr = server.config.command ? `${server.config.command} ${(server.config.args ?? []).join(" ")}` : server.config.url ?? "";
         const hasCachedTools = server.tools.length > 0;
-        const sourceLabel = server.status === "connected" ? " (live)" : hasCachedTools ? " (from cache)" : "";
+        const sourceLabel = server.status === "connected" ? serverT({ en: " (live)", fr: " (en direct)" }) : hasCachedTools ? serverT({ en: " (from cache)", fr: " (depuis le cache)" }) : "";
         const statusLine = server.error ? `${server.status}${sourceLabel}: ${server.error}` : `${server.status}${sourceLabel}`;
         lines.push(`${connStr} ${server.name} (${server.config.transport}) \u2014 ${statusLine}`);
         lines.push(`  ${cmdStr}`);
-        lines.push(`  ${server.tools.length} tools, ~${server.estimatedTokens} tokens`);
+        lines.push(
+          serverT(
+            { en: "  {{count}} tools, ~{{tokens}} tokens", fr: "  {{count}} outils, ~{{tokens}} tokens" },
+            { count: server.tools.length, tokens: server.estimatedTokens }
+          )
+        );
         const enabledTools = server.tools.filter((t) => t.enabled);
         const disabledTools = server.tools.filter((t) => !t.enabled);
         if (enabledTools.length > 0) {
-          lines.push(`  Enabled: ${enabledTools.map((t) => t.name).join(", ")}`);
+          lines.push(
+            serverT(
+              { en: "  Enabled: {{list}}", fr: "  Activ\xE9s : {{list}}" },
+              { list: enabledTools.map((t) => t.name).join(", ") }
+            )
+          );
         }
         if (disabledTools.length > 0) {
-          lines.push(`  Disabled: ${disabledTools.map((t) => t.name).join(", ")}`);
+          lines.push(
+            serverT(
+              { en: "  Disabled: {{list}}", fr: "  D\xE9sactiv\xE9s : {{list}}" },
+              { list: disabledTools.map((t) => t.name).join(", ") }
+            )
+          );
         }
       }
       return helpers.success(lines.join("\n"));
     }
     if (args.action === "add") {
-      if (!args.name) return helpers.error("Missing required field: name");
+      if (!args.name)
+        return helpers.error(serverT({ en: "Missing required field: name", fr: "Champ requis manquant : name" }));
       if (args.transport === "http") {
-        if (!args.url) return helpers.error("url is required for http transport");
+        if (!args.url)
+          return helpers.error(
+            serverT({ en: "url is required for http transport", fr: "url est requis pour le transport http" })
+          );
       } else if (!args.command) {
-        return helpers.error("command is required for stdio transport");
+        return helpers.error(
+          serverT({ en: "command is required for stdio transport", fr: "command est requis pour le transport stdio" })
+        );
       }
       if (args.timeout !== void 0 && (typeof args.timeout !== "number" || args.timeout <= 0)) {
-        return helpers.error("timeout must be a positive number");
+        return helpers.error(
+          serverT({ en: "timeout must be a positive number", fr: "timeout doit \xEAtre un nombre positif" })
+        );
       }
       const serverCfg = {
         transport: args.transport ?? "stdio",
@@ -4286,12 +4569,27 @@ var mcpConfigTool = createTool(
       await notifyContextChanged(context.sessionId);
       const server = mcpManagerForTools.getServer(args.name);
       const toolCount = server?.tools.length ?? 0;
-      return helpers.success(`Added MCP server "${args.name}" (${toolCount} tools discovered). ${APPLY_PROMPT_MESSAGE}`);
+      return helpers.success(
+        serverT(
+          {
+            en: 'Added MCP server "{{name}}" ({{count}} tools discovered). {{prompt}}',
+            fr: "Serveur MCP \xAB {{name}} \xBB ajout\xE9 ({{count}} outils d\xE9couverts). {{prompt}}"
+          },
+          { name: args.name ?? "", count: toolCount, prompt: APPLY_PROMPT_MESSAGE }
+        )
+      );
     }
     if (args.action === "update") {
-      if (!args.name) return helpers.error("Missing required field: name");
+      if (!args.name)
+        return helpers.error(serverT({ en: "Missing required field: name", fr: "Champ requis manquant : name" }));
       const existing = mcpManagerForTools.getServer(args.name);
-      if (!existing) return helpers.error(`MCP server "${args.name}" not found`);
+      if (!existing)
+        return helpers.error(
+          serverT(
+            { en: 'MCP server "{{name}}" not found', fr: "Serveur MCP \xAB {{name}} \xBB introuvable" },
+            { name: args.name ?? "" }
+          )
+        );
       const globalConfig = await loadGlobalConfig(mcpConfigMode, mcpConfigPath);
       const mcpServers = { ...globalConfig.mcpServers ?? {} };
       const patch = {
@@ -4320,11 +4618,18 @@ var mcpConfigTool = createTool(
       const server = mcpManagerForTools.getServer(args.name);
       const toolCount = server?.tools.length ?? 0;
       return helpers.success(
-        `Updated MCP server "${args.name}" (${toolCount} tools discovered). ${APPLY_PROMPT_MESSAGE}`
+        serverT(
+          {
+            en: 'Updated MCP server "{{name}}" ({{count}} tools discovered). {{prompt}}',
+            fr: "Serveur MCP \xAB {{name}} \xBB mis \xE0 jour ({{count}} outils d\xE9couverts). {{prompt}}"
+          },
+          { name: args.name ?? "", count: toolCount, prompt: APPLY_PROMPT_MESSAGE }
+        )
       );
     }
     if (args.action === "remove") {
-      if (!args.name) return helpers.error("Missing required field: name");
+      if (!args.name)
+        return helpers.error(serverT({ en: "Missing required field: name", fr: "Champ requis manquant : name" }));
       await persistAndRebuild((mcpServers) => {
         delete mcpServers[args.name];
         return mcpServers;
@@ -4332,12 +4637,22 @@ var mcpConfigTool = createTool(
       mcpManagerForTools.removeServer(args.name);
       await rebuildTools();
       await notifyContextChanged(context.sessionId);
-      return helpers.success(`Removed MCP server "${args.name}". ${APPLY_PROMPT_MESSAGE}`);
+      return helpers.success(
+        serverT(
+          { en: 'Removed MCP server "{{name}}". {{prompt}}', fr: "Serveur MCP \xAB {{name}} \xBB supprim\xE9. {{prompt}}" },
+          { name: args.name ?? "", prompt: APPLY_PROMPT_MESSAGE }
+        )
+      );
     }
     if (args.action === "toggle-tool") {
-      if (!args.name) return helpers.error("Missing required field: name");
-      if (!args.toolName) return helpers.error("Missing required field: toolName");
-      if (args.enabled === void 0) return helpers.error("Missing required field: enabled");
+      if (!args.name)
+        return helpers.error(serverT({ en: "Missing required field: name", fr: "Champ requis manquant : name" }));
+      if (!args.toolName)
+        return helpers.error(
+          serverT({ en: "Missing required field: toolName", fr: "Champ requis manquant : toolName" })
+        );
+      if (args.enabled === void 0)
+        return helpers.error(serverT({ en: "Missing required field: enabled", fr: "Champ requis manquant : enabled" }));
       const server = mcpManagerForTools.getServer(args.name);
       const currentDisabled = (server?.tools ?? []).filter((t) => !t.enabled).map((t) => t.name);
       const afterDisabled = args.enabled ? currentDisabled.filter((n) => n !== args.toolName) : [...currentDisabled, args.toolName];
@@ -4358,10 +4673,21 @@ var mcpConfigTool = createTool(
       await rebuildTools();
       await notifyContextChanged(context.sessionId);
       return helpers.success(
-        `Tool "${args.toolName}" ${args.enabled ? "enabled" : "disabled"} on server "${args.name}". ${APPLY_PROMPT_MESSAGE}`
+        serverT(
+          {
+            en: 'Tool "{{tool}}" {{state}} on server "{{name}}". {{prompt}}',
+            fr: "Outil \xAB {{tool}} \xBB {{state}} sur le serveur \xAB {{name}} \xBB. {{prompt}}"
+          },
+          {
+            tool: args.toolName ?? "",
+            state: args.enabled ? serverT({ en: "enabled", fr: "activ\xE9" }) : serverT({ en: "disabled", fr: "d\xE9sactiv\xE9" }),
+            name: args.name ?? "",
+            prompt: APPLY_PROMPT_MESSAGE
+          }
+        )
       );
     }
-    return helpers.error("Unexpected error");
+    return helpers.error(serverT({ en: "Unexpected error", fr: "Erreur inattendue" }));
   }
 );
 
@@ -4474,7 +4800,10 @@ var webSearchTool = createTool(
     const active = getActiveEngine();
     if (!active) {
       return helpers.error(
-        "web_search requires at least one search engine configured. Set the TAVILY_API_KEY environment variable, or configure SearXNG via SEARXNG_URL (and optionally SEARXNG_API_KEY). You can also configure these in Settings > Advanced > Search Engine."
+        serverT({
+          en: "web_search requires at least one search engine configured. Set the TAVILY_API_KEY environment variable, or configure SearXNG via SEARXNG_URL (and optionally SEARXNG_API_KEY). You can also configure these in Settings > Advanced > Search Engine.",
+          fr: "web_search n\xE9cessite au moins un moteur de recherche configur\xE9. D\xE9finissez la variable d\u2019environnement TAVILY_API_KEY, ou configurez SearXNG via SEARXNG_URL (et \xE9ventuellement SEARXNG_API_KEY). Vous pouvez aussi les configurer dans Param\xE8tres > Avanc\xE9 > Moteur de recherche."
+        })
       );
     }
     const signal = buildSignal(DEFAULT_TIMEOUT_MS2, context.signal);
@@ -4488,14 +4817,24 @@ var webSearchTool = createTool(
         results = await searchSearxng(query, maxResults, searxngConfig, signal);
       }
       if (results.length === 0) {
-        return helpers.success("No search results found.", false);
+        return helpers.success(
+          serverT({ en: "No search results found.", fr: "Aucun r\xE9sultat de recherche trouv\xE9." }),
+          false
+        );
       }
       return helpers.success(formatResults(results), false);
     } catch (error) {
       if (error instanceof DOMException && error.name === "AbortError") {
-        return helpers.error("Search request timed out (15s). Try a more specific query.");
+        return helpers.error(
+          serverT({
+            en: "Search request timed out (15s). Try a more specific query.",
+            fr: "La recherche a expir\xE9 (15 s). Essayez une requ\xEAte plus pr\xE9cise."
+          })
+        );
       }
-      return helpers.error(error instanceof Error ? error.message : "Search request failed");
+      return helpers.error(
+        error instanceof Error ? error.message : serverT({ en: "Search request failed", fr: "\xC9chec de la requ\xEAte de recherche" })
+      );
     }
   }
 );
@@ -4559,22 +4898,43 @@ Actions:
     const { sessionId, sessionManager } = context;
     const validActions = ["switch", "list", "delete"];
     if (!validActions.includes(args.action)) {
-      return helpers.error(`Invalid action: ${args.action}. Must be one of: ${validActions.join(", ")}`);
+      return helpers.error(
+        serverT(
+          {
+            en: "Invalid action: {{action}}. Must be one of: {{allowed}}",
+            fr: "Action invalide : {{action}}. Doit \xEAtre l\u2019une des actions suivantes : {{allowed}}"
+          },
+          { action: args.action, allowed: validActions.join(", ") }
+        )
+      );
     }
     switch (args.action) {
       case "switch": {
         if (!args.target || typeof args.target !== "string") {
-          return helpers.error('Parameter "target" is required for action=switch ("original" or a workspace name)');
+          return helpers.error(
+            serverT({
+              en: 'Parameter "target" is required for action=switch ("original" or a workspace name)',
+              fr: "Le param\xE8tre \xAB target \xBB est requis pour action=switch (\xAB original \xBB ou un nom de workspace)"
+            })
+          );
         }
         if (await isGitRepository(context.workdir) === false) {
-          return helpers.error("Project is not a git repository");
+          return helpers.error(
+            serverT({ en: "Project is not a git repository", fr: "Le projet n\u2019est pas un d\xE9p\xF4t git" })
+          );
         }
         const currentSession = sessionManager.getSession(sessionId);
         const isBranchChange = args.branch !== void 0 && currentSession != null && args.target !== "original" && currentSession.workspace?.split("/").pop() === args.target;
         const label = args.target === "original" ? "original project" : `workspace "${args.target}"`;
         const desc = isBranchChange ? `Change branch to "${args.branch}" on ${label}` : `Switch to ${label}${args.branch ? ` on branch "${args.branch}"` : ""}`;
         const approved = await requestUserConfirmation(context, "workspace", desc);
-        if (!approved) return helpers.error(`User denied: ${isBranchChange ? "branch change" : `switch to ${label}`}`);
+        if (!approved)
+          return helpers.error(
+            serverT(
+              { en: "User denied: {{what}}", fr: "Refus\xE9 par l\u2019utilisateur : {{what}}" },
+              { what: isBranchChange ? "branch change" : `switch to ${label}` }
+            )
+          );
         const updated = await sessionManager.switchWorkspace(sessionId, args.target, args.branch, args.sourceBranch);
         const wsName = args.target === "original" ? "original" : updated.workspace?.split("/").pop() ?? args.target;
         const branch = await getGitBranch(updated.workspace ?? updated.workdir);
@@ -4584,7 +4944,13 @@ Actions:
               workspace: wsName,
               path: updated.workspace ?? updated.workdir,
               branch,
-              message: args.target === "original" ? "Switched to original project" : `Switched to workspace "${wsName}" on branch "${branch ?? "unknown"}"`
+              message: args.target === "original" ? serverT({ en: "Switched to original project", fr: "Basculement vers le projet d\u2019origine" }) : serverT(
+                {
+                  en: 'Switched to workspace "{{name}}" on branch "{{branch}}"',
+                  fr: "Basculement vers le workspace \xAB {{name}} \xBB sur la branche \xAB {{branch}} \xBB"
+                },
+                { name: wsName, branch: branch ?? "unknown" }
+              )
             },
             null,
             2
@@ -4593,9 +4959,9 @@ Actions:
       }
       case "list": {
         const session = sessionManager.getSession(sessionId);
-        if (!session) return helpers.error("Session not found");
+        if (!session) return helpers.error(serverT({ en: "Session not found", fr: "Session introuvable" }));
         const project = sessionManager.getProject(session.projectId);
-        if (!project) return helpers.error("Project not found");
+        if (!project) return helpers.error(serverT({ en: "Project not found", fr: "Projet introuvable" }));
         const currentBranch = await getGitBranch(sessionManager.getEffectiveWorkdir(session.id));
         const named = await listWorkspaces(project.name, project.workdir);
         const activeWsName = session.workspace?.split("/").pop() ?? null;
@@ -4611,11 +4977,24 @@ Actions:
       }
       case "delete": {
         if (!args.target || typeof args.target !== "string") {
-          return helpers.error('Parameter "target" is required for action=delete (the workspace name)');
+          return helpers.error(
+            serverT({
+              en: 'Parameter "target" is required for action=delete (the workspace name)',
+              fr: "Le param\xE8tre \xAB target \xBB est requis pour action=delete (le nom du workspace)"
+            })
+          );
         }
-        if (args.target === "original") return helpers.error("Cannot delete the original workspace");
+        if (args.target === "original")
+          return helpers.error(
+            serverT({
+              en: "Cannot delete the original workspace",
+              fr: "Impossible de supprimer le workspace d\u2019origine"
+            })
+          );
         if (await isGitRepository(context.workdir) === false) {
-          return helpers.error("Project is not a git repository");
+          return helpers.error(
+            serverT({ en: "Project is not a git repository", fr: "Le projet n\u2019est pas un d\xE9p\xF4t git" })
+          );
         }
         const forceDesc = args.force ? " (will auto-switch other sessions to original)" : "";
         const approved = await requestUserConfirmation(
@@ -4623,13 +5002,25 @@ Actions:
           "workspace",
           `Delete workspace "${args.target}"${forceDesc}`
         );
-        if (!approved) return helpers.error(`User denied: delete workspace "${args.target}"`);
+        if (!approved)
+          return helpers.error(
+            serverT(
+              {
+                en: 'User denied: delete workspace "{{name}}"',
+                fr: "Refus\xE9 par l\u2019utilisateur : supprimer le workspace \xAB {{name}} \xBB"
+              },
+              { name: args.target }
+            )
+          );
         await sessionManager.deleteWorkspace(sessionId, args.target, args.force === true);
         return helpers.success(
           JSON.stringify(
             {
               workspace: args.target,
-              message: `Workspace "${args.target}" has been deleted`
+              message: serverT(
+                { en: 'Workspace "{{name}}" has been deleted', fr: "Le workspace \xAB {{name}} \xBB a \xE9t\xE9 supprim\xE9" },
+                { name: args.target }
+              )
             },
             null,
             2
@@ -4637,7 +5028,9 @@ Actions:
         );
       }
       default:
-        return helpers.error(`Unknown action: ${args.action}`);
+        return helpers.error(
+          serverT({ en: "Unknown action: {{action}}", fr: "Action inconnue : {{action}}" }, { action: args.action })
+        );
     }
   }
 );
@@ -4709,7 +5102,7 @@ var projectTasksTool = createTool(
     const permError = validateActionWithPermission(action, VALID_ACTIONS, "project_tasks", context.permittedActions);
     if (permError) return permError;
     const session = context.sessionManager.getSession(context.sessionId);
-    if (!session) return helpers.error("Session not found");
+    if (!session) return helpers.error(serverT({ en: "Session not found", fr: "Session introuvable" }));
     const projectId = session.projectId;
     const svc = getTasksService();
     const actor = { actor: "agent", actorName: "agent" };
@@ -4719,7 +5112,13 @@ var projectTasksTool = createTool(
           const status = args.status;
           if (status !== void 0 && !LIST_STATUSES.includes(status)) {
             return helpers.error(
-              `Invalid "status" filter for action=list: "${String(status)}". Expected one of: todo, in_progress, done, all.`
+              serverT(
+                {
+                  en: 'Invalid "status" filter for action=list: "{{status}}". Expected one of: todo, in_progress, done, all.',
+                  fr: "Filtre \xAB status \xBB invalide pour action=list : \xAB {{status}} \xBB. Valeurs attendues : todo, in_progress, done, all."
+                },
+                { status: String(status) }
+              )
             );
           }
           const page = parseListPage(args.limit, args.offset);
@@ -4758,7 +5157,13 @@ var projectTasksTool = createTool(
           return helpers.success(JSON.stringify(taskForAgent(task), null, 2));
         }
         case "edit": {
-          if (!args.taskId) return helpers.error('Parameter "taskId" is required for action=edit');
+          if (!args.taskId)
+            return helpers.error(
+              serverT({
+                en: 'Parameter "taskId" is required for action=edit',
+                fr: "Le param\xE8tre \xAB taskId \xBB est requis pour action=edit"
+              })
+            );
           const result = await svc.update(
             projectId,
             args.taskId,
@@ -4775,9 +5180,20 @@ var projectTasksTool = createTool(
           return helpers.success(JSON.stringify(taskForAgent(result.task), null, 2));
         }
         case "move": {
-          if (!args.taskId) return helpers.error('Parameter "taskId" is required for action=move');
+          if (!args.taskId)
+            return helpers.error(
+              serverT({
+                en: 'Parameter "taskId" is required for action=move',
+                fr: "Le param\xE8tre \xAB taskId \xBB est requis pour action=move"
+              })
+            );
           if (!args.to)
-            return helpers.error('Parameter "to" is required for action=move ("todo" | "in_progress" | "done")');
+            return helpers.error(
+              serverT({
+                en: 'Parameter "to" is required for action=move ("todo" | "in_progress" | "done")',
+                fr: "Le param\xE8tre \xAB to \xBB est requis pour action=move (\xAB todo \xBB | \xAB in_progress \xBB | \xAB done \xBB)"
+              })
+            );
           const result = await svc.move(projectId, args.taskId, args.to, {
             actor: "agent",
             actorName: "agent",
@@ -4788,9 +5204,27 @@ var projectTasksTool = createTool(
           return helpers.success(JSON.stringify(taskForAgent(result.task), null, 2));
         }
         case "set_gate_value": {
-          if (!args.taskId) return helpers.error('Parameter "taskId" is required for action=set_gate_value');
-          if (!args.gateId) return helpers.error('Parameter "gateId" is required for action=set_gate_value');
-          if (args.value === void 0) return helpers.error('Parameter "value" is required for action=set_gate_value');
+          if (!args.taskId)
+            return helpers.error(
+              serverT({
+                en: 'Parameter "taskId" is required for action=set_gate_value',
+                fr: "Le param\xE8tre \xAB taskId \xBB est requis pour action=set_gate_value"
+              })
+            );
+          if (!args.gateId)
+            return helpers.error(
+              serverT({
+                en: 'Parameter "gateId" is required for action=set_gate_value',
+                fr: "Le param\xE8tre \xAB gateId \xBB est requis pour action=set_gate_value"
+              })
+            );
+          if (args.value === void 0)
+            return helpers.error(
+              serverT({
+                en: 'Parameter "value" is required for action=set_gate_value',
+                fr: "Le param\xE8tre \xAB value \xBB est requis pour action=set_gate_value"
+              })
+            );
           const result = await svc.setGateValue(
             projectId,
             args.taskId,
@@ -4803,9 +5237,18 @@ var projectTasksTool = createTool(
           return helpers.success(JSON.stringify(taskForAgent(result.task), null, 2));
         }
         case "delete": {
-          if (!args.taskId) return helpers.error('Parameter "taskId" is required for action=delete');
+          if (!args.taskId)
+            return helpers.error(
+              serverT({
+                en: 'Parameter "taskId" is required for action=delete',
+                fr: "Le param\xE8tre \xAB taskId \xBB est requis pour action=delete"
+              })
+            );
           const task = svc.get(projectId, args.taskId);
-          if (!task) return helpers.error(`Task not found: ${args.taskId}`);
+          if (!task)
+            return helpers.error(
+              serverT({ en: "Task not found: {{id}}", fr: "T\xE2che introuvable : {{id}}" }, { id: args.taskId ?? "" })
+            );
           await svc.remove(projectId, args.taskId, actor);
           return helpers.success(
             JSON.stringify(
@@ -4816,18 +5259,32 @@ var projectTasksTool = createTool(
           );
         }
         default:
-          return helpers.error(`Unknown action: ${String(action)}`);
+          return helpers.error(
+            serverT(
+              { en: "Unknown action: {{action}}", fr: "Action inconnue : {{action}}" },
+              { action: String(action) }
+            )
+          );
       }
     } catch (error) {
       if (isTaskGateError(error)) {
         const missing = error.missing.map((m) => `'${m.name}' (${m.gateId}): ${m.description}`).join("; ");
         return helpers.error(
-          `Move blocked by column gates. Missing required gate fields: ${missing}. Fill them with action=set_gate_value (taskId, gateId, value=<acceptable proof>) and then call move again. You set these values as part of your work \u2014 this is the intended loop, not a dead end.`
+          serverT(
+            {
+              en: "Move blocked by column gates. Missing required gate fields: {{missing}}. Fill them with action=set_gate_value (taskId, gateId, value=<acceptable proof>) and then call move again. You set these values as part of your work \u2014 this is the intended loop, not a dead end.",
+              fr: "D\xE9placement bloqu\xE9 par les portes de colonne. Champs de porte requis manquants : {{missing}}. Renseignez-les avec action=set_gate_value (taskId, gateId, value=<preuve acceptable>) puis appelez \xE0 nouveau move. Vous d\xE9finissez ces valeurs dans le cadre de votre travail \u2014 c\u2019est la boucle pr\xE9vue, pas une impasse."
+            },
+            { missing }
+          )
         );
       }
       if (isTaskConflictError(error)) {
         return helpers.error(
-          `Task changed, refresh and retry. Another actor modified this task since your last read. Re-list and retry with the latest updatedAt.`
+          serverT({
+            en: "Task changed, refresh and retry. Another actor modified this task since your last read. Re-list and retry with the latest updatedAt.",
+            fr: "T\xE2che modifi\xE9e, actualisez et r\xE9essayez. Un autre acteur a modifi\xE9 cette t\xE2che depuis votre derni\xE8re lecture. Re-listez et r\xE9essayez avec le updatedAt le plus r\xE9cent."
+          })
         );
       }
       throw error;
@@ -5158,4 +5615,4 @@ export {
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-HXHPKGJE.js.map
+//# sourceMappingURL=chunk-J5HOUEPE.js.map