create-snipara 1.3.39 → 1.3.41

package/README.md

@@ -16,7 +16,7 @@ so an LLM client can use Snipara context and reviewed memory.
 
 Use it for:
 
-- Hosted MCP onboarding for Claude Code, Cursor, Windsurf, Codex, Gemini, VS Code/Copilot, Continue, ChatGPT Desktop, and similar clients
+- Hosted MCP onboarding for Claude Code, Cursor, Windsurf, Codex, Gemini, Mistral, VS Code/Copilot, Continue, ChatGPT Desktop, and similar clients
 - free account signup with reviewed Context + Memory
 - local project wiring, `doctor`, `repair`, and `upgrade`
 - GitHub repository sync and PR Answer Packs approval when the current folder is a GitHub repo
@@ -33,7 +33,7 @@ flowchart LR
     CLI --> Auth["Snipara auth and project key"]
     CLI --> MCP["Hosted MCP config"]
     CLI --> Templates["AGENTS.md, CLAUDE.md, Cursor, Codex, MCP references"]
-    MCP --> Agents["Claude Code, Cursor, Codex, Gemini, VS Code, ChatGPT"]
+    MCP --> Agents["Claude Code, Cursor, Codex, Gemini, Mistral, VS Code, ChatGPT"]
     Templates --> Agents
     Agents --> Context["Snipara context and memory"]
 ```
@@ -75,7 +75,7 @@ Free onboarding is now **Context + Memory**, not Context-only:
 
 - Context Free: three projects and 1,000 context queries/month
 - Memory Free: reviewed hosted memories for continuity across sessions
-- Hosted MCP: direct connection for Claude Code, Cursor, Windsurf, Codex, Gemini, VS Code/Copilot, Continue, ChatGPT Desktop, and other MCP clients
+- Hosted MCP: direct connection for Claude Code, Cursor, Windsurf, Codex, Gemini, Mistral, VS Code/Copilot, Continue, ChatGPT Desktop, and other MCP clients
 
 The CLI opens a browser device-flow login when the user does not already have a key, auto-provisions the free Context + Memory account when needed, then writes the returned API key into the local MCP config.
 
@@ -108,6 +108,9 @@ That distinction matters:
 - generates merge-ready AI agent templates in `.snipara/templates/`, including Pro+ symbol-card, code-impact, and managed workflow guidance for paid Context plans
 - creates `AGENTS.md` and `CLAUDE.md` when missing, or appends a marked Snipara section when those files already exist
 - creates `.cursor/rules/snipara.mdc` and `.codex/config.toml` when those files do not already exist
+- validates Codex config against Hosted MCP plus `bearer_token_env_var = "SNIPARA_API_KEY"` and tells users to restart Codex after MCP config changes
+- runs a real hosted MCP `tools/list` check and warns if the server still advertises legacy `rlm_*` duplicate tools
+- generates Mistral Le Chat, Mistral Vibe, and LangChain `ChatMistralAI.bindTools` references without embedding secrets
 - writes client-specific companion packs such as `.snipara/companion/CODEX.md` or `.snipara/companion/GEMINI.md`
 - updates `.env`, `.env.local`, and `.env.example`
 - generates `.snipara/companion/README.md`
@@ -161,8 +164,16 @@ The generated agent templates cover:
 - Cursor `.cursor/rules/snipara.mdc`
 - Codex `.codex/config.toml` snippet
 - ChatGPT/OpenAI HTTP MCP snippet
+- Mistral Le Chat connector, Vibe config, and LangChain `ChatMistralAI.bindTools` snippets
 - Gemini, VS Code, Continue, and custom HTTP MCP reference snippets
 
+For Codex, `SNIPARA_API_KEY` is the only generated bearer token environment
+variable. If Codex lazily exposes only a minimal Snipara MCP surface after
+restart, force exact discovery for `snipara_recall`, `snipara_context_query`,
+and `snipara_settings`. Use `snipara-companion recall`, `snipara-companion
+query`, and `snipara-companion task-commit` as the reliable local fallback while
+the Codex session reloads or rediscovers tools.
+
 Existing root `AGENTS.md` and `CLAUDE.md` files are not replaced. The installer
 adds or refreshes a marked Snipara section so project-specific instructions stay
 intact.
@@ -344,8 +355,11 @@ companion add workflow ergonomics:
 
 Claude Code, Cursor, and Windsurf can receive generated automation files when
 that client has a useful local hook surface. Codex, Gemini, VS Code, Continue,
-ChatGPT, and custom clients are treated as MCP-first: they get the hosted MCP
+Mistral, ChatGPT, and custom clients are treated as MCP-first: they get the hosted MCP
 configuration/reference and agent instructions, not invented local hooks.
+For Mistral, request hooks from LangChain are documented as `ChatMistralAI`
+request lifecycle hooks (`beforeRequestHooks`, `requestErrorHooks`, and
+`responseHooks`), not as local agent lifecycle hooks.
 
 OpenClaw is the specialized exception: use `snipara-openclaw-install` for a
 single OpenClaw-focused setup command, or use `create-snipara` plus

package/dist/index.js

@@ -13,7 +13,7 @@ import { homedir } from "os";
 // package.json
 var package_default = {
   name: "create-snipara",
-  version: "1.3.39",
+  version: "1.3.41",
   description: "Onboard Snipara Hosted MCP Context + Memory with auth, companion workflows, and optional Snipara Sandbox",
   main: "dist/index.js",
   type: "module",
@@ -47,6 +47,7 @@ var package_default = {
     "cursor",
     "windsurf",
     "gemini",
+    "mistral",
     "vscode",
     "continue",
     "claude-desktop"
@@ -128,6 +129,11 @@ var AI_CLIENT_CHOICES = [
     value: "gemini",
     description: "Hosted MCP reference plus agent instructions"
   },
+  {
+    title: "Mistral Le Chat / Vibe",
+    value: "mistral",
+    description: "Le Chat custom MCP connector plus Mistral Vibe config"
+  },
   {
     title: "VS Code / Copilot",
     value: "vscode",
@@ -157,6 +163,7 @@ function getCompanionInitClientFlag(aiClient) {
     windsurf: "windsurf",
     codex: "codex",
     gemini: "gemini",
+    mistral: "mistral",
     chatgpt: "chatgpt",
     vscode: "vscode",
     continue: "continue",
@@ -176,7 +183,7 @@ function buildProgram() {
   program.name("create-snipara").description("Scaffold hosted Snipara MCP config plus companion workflow helpers").version(VERSION);
   program.command("init").description("Install and configure Snipara for this project").option("--api-key <key>", "Snipara API key").option("--slug <slug>", "Project slug").option("--project-id <id>", "Project ID").option(
     "--client <client>",
-    "AI client: claude-code, cursor, windsurf, codex, gemini, chatgpt, vscode, continue, claude-desktop, other"
+    "AI client: claude-code, cursor, windsurf, codex, gemini, mistral, chatgpt, vscode, continue, claude-desktop, other"
   ).option("--advanced", "Show advanced profile, project id, hooks, GitHub, and sandbox prompts").option(
     "--profile <profile>",
     "Install profile: hosted-only, hosted-companion, full-stack, runtime-only"
@@ -213,7 +220,7 @@ function buildProgram() {
 function addSharedRootOptions(program) {
   program.option("--api-key <key>", "Snipara API key").option("--slug <slug>", "Project slug").option("--project-id <id>", "Project ID").option(
     "--client <client>",
-    "AI client: claude-code, cursor, windsurf, codex, gemini, chatgpt, vscode, continue, claude-desktop, other"
+    "AI client: claude-code, cursor, windsurf, codex, gemini, mistral, chatgpt, vscode, continue, claude-desktop, other"
   ).option("--advanced", "Show advanced profile, project id, hooks, GitHub, and sandbox prompts").option(
     "--profile <profile>",
     "Install profile: hosted-only, hosted-companion, full-stack, runtime-only"
@@ -607,7 +614,10 @@ async function gatherConfiguration(options) {
   let signupResult = null;
   if (!apiKey && response.profile !== "runtime-only") {
     if (response.apiKeyType === "signup") {
-      signupResult = await handleSignup();
+      signupResult = await handleSignup({
+        projectHint: response.projectSlug,
+        repoHint: detectedGitRepo?.fullName
+      });
       apiKey = signupResult.apiKey;
       apiKeyType = "api";
     } else if (response.apiKeyType === "api") {
@@ -719,6 +729,12 @@ function normalizeClientOption(value) {
     windsurf: "windsurf",
     codex: "codex",
     gemini: "gemini",
+    mistral: "mistral",
+    "le-chat": "mistral",
+    lechat: "mistral",
+    vibe: "mistral",
+    "mistral-vibe": "mistral",
+    mistral_vibe: "mistral",
     chatgpt: "chatgpt",
     vscode: "vscode",
     continue: "continue",
@@ -727,7 +743,9 @@ function normalizeClientOption(value) {
   };
   const client = aliases[normalized];
   if (!client) {
-    throw new Error(`Unknown client '${value}'. Use claude, claude-code, cursor, codex, or other.`);
+    throw new Error(
+      `Unknown client '${value}'. Use claude, claude-code, cursor, codex, mistral, or other.`
+    );
   }
   return client;
 }
@@ -800,10 +818,10 @@ function buildAnswersFromProfile(input) {
     githubPath: input.githubPath
   };
 }
-async function handleSignup() {
+async function handleSignup(hints = {}) {
   console.log(chalk.bold("\n\u{1F510} Browser Account Authorization\n"));
   try {
-    return await runDeviceAuthorization();
+    return await runDeviceAuthorization(hints);
   } catch (error) {
     if (error instanceof DeviceAuthorizationAborted) {
       throw error;
@@ -831,7 +849,27 @@ async function handleManualSignup() {
   });
   return { apiKey: response.apiKey };
 }
-async function runDeviceAuthorization() {
+function normalizeDeviceFlowHint(value) {
+  const normalized = value?.trim();
+  return normalized && !normalized.includes("<") && !normalized.includes(">") ? normalized : null;
+}
+function appendDeviceFlowHints(url, hints) {
+  try {
+    const parsed = new URL(url);
+    const projectHint = normalizeDeviceFlowHint(hints.projectHint);
+    const repoHint = normalizeDeviceFlowHint(hints.repoHint);
+    if (projectHint) {
+      parsed.searchParams.set("project_hint", projectHint);
+    }
+    if (repoHint) {
+      parsed.searchParams.set("repo_hint", repoHint);
+    }
+    return parsed.toString();
+  } catch {
+    return url;
+  }
+}
+async function runDeviceAuthorization(hints = {}) {
   const codeResponse = await postJson(`${BASE_URL}/api/oauth/device/code`, {
     client_id: DEVICE_CLIENT_ID,
     scope: "mcp:read mcp:write",
@@ -840,11 +878,10 @@ async function runDeviceAuthorization() {
   if (codeResponse.error) {
     throw new Error(codeResponse.error_description || codeResponse.error);
   }
-  console.log(
-    chalk.cyan(`   Opening ${codeResponse.verification_uri_complete} in your browser...`)
-  );
+  const verificationUrl = appendDeviceFlowHints(codeResponse.verification_uri_complete, hints);
+  console.log(chalk.cyan(`   Opening ${verificationUrl} in your browser...`));
   console.log(chalk.dim(`   Device code: ${codeResponse.user_code}`));
-  openBrowser(codeResponse.verification_uri_complete);
+  openBrowser(verificationUrl);
   const spinner = ora("Waiting for Snipara authorization in the browser...").start();
   const startedAt = Date.now();
   let intervalMs = Math.max(1, codeResponse.interval || 5) * 1e3;
@@ -1212,6 +1249,18 @@ async function createAgentTemplates(answers) {
       path: path.join(templatesDir, "gemini-mcp-reference.json"),
       content: buildGenericMcpReferenceTemplate(answers, "gemini")
     },
+    {
+      path: path.join(templatesDir, "mistral-vibe-config.toml"),
+      content: buildMistralVibeConfigTemplate(answers)
+    },
+    {
+      path: path.join(templatesDir, "mistral-le-chat-mcp.json"),
+      content: buildMistralLeChatTemplate(answers)
+    },
+    {
+      path: path.join(templatesDir, "mistral-langchain-tools.ts"),
+      content: buildMistralLangChainToolsTemplate(answers)
+    },
     {
       path: path.join(templatesDir, "vscode-mcp-reference.json"),
       content: buildGenericMcpReferenceTemplate(answers, "vscode")
@@ -1253,6 +1302,15 @@ async function createAgentTemplates(answers) {
     buildCodexConfigTemplate(answers),
     ".codex/config.toml"
   );
+  if (answers.aiClient === "mistral") {
+    const vibeDir = path.join(process.cwd(), ".vibe");
+    fs.mkdirSync(vibeDir, { recursive: true });
+    writeIfMissing(
+      path.join(vibeDir, "config.toml"),
+      buildMistralVibeConfigTemplate(answers),
+      ".vibe/config.toml"
+    );
+  }
   ensureGitignoreEntry(".snipara/companion/doctor.json", "# Snipara generated validation output");
 }
 function writeIfMissing(filePath, content, label) {
@@ -1281,10 +1339,17 @@ This project uses Snipara Hosted MCP for project context and reviewed memory.
   call such as \`snipara_settings\`, \`tools/list\`, or a lightweight
   \`snipara_context_query\`. Do not treat empty MCP resources/templates as an
   outage because Snipara may be tool-only.
+- In Codex, if only a minimal Snipara tool subset appears, force precise tool
+  discovery for \`snipara_recall\`, \`snipara_context_query\`, and
+  \`snipara_settings\` before concluding the MCP server is incomplete.
 - If a session appears to expose only a subset of expected Snipara tools, call
   \`snipara_help(list_all=true)\` and compare exact tool names before concluding
   that a tool is unavailable. Do not infer absence from one broad discovery
   pass or a ranked tool-search result.
+- If Codex still exposes only a partial surface after exact discovery, use
+  \`snipara-companion recall\`, \`snipara-companion query\`, and
+  \`snipara-companion task-commit\` as the reliable local fallback, then restart
+  or reload Codex after MCP config changes.
 
 Agent task lifecycle:
 
@@ -1408,6 +1473,138 @@ function buildChatGptMcpTemplate(answers) {
   )}
 `;
 }
+function buildMistralVibeConfigTemplate(answers) {
+  return `[[mcp_servers]]
+name = "snipara"
+transport = "streamable-http"
+url = "${buildHostedMcpEndpoint(answers)}"
+api_key_env = "SNIPARA_API_KEY"
+api_key_header = "X-API-Key"
+api_key_format = "{token}"
+`;
+}
+function buildMistralLeChatTemplate(answers) {
+  return `${JSON.stringify(
+    {
+      connector_name: "snipara",
+      server_url: buildHostedMcpEndpoint(answers),
+      auth: {
+        method: "HTTP Bearer Token or Basic/API key prompt",
+        secret: "Use SNIPARA_API_KEY from your environment or secret store"
+      },
+      notes: [
+        "In Le Chat, add a Custom MCP Connector with this Server URL.",
+        "Le Chat auto-detects the authentication flow; do not commit the API key.",
+        "Enable the connector tools in each conversation or pre-authorize read functions deliberately."
+      ]
+    },
+    null,
+    2
+  )}
+`;
+}
+function buildMistralLangChainToolsTemplate(answers) {
+  return `import { ChatMistralAI } from "@langchain/mistralai";
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+
+const SNIPARA_MCP_URL = process.env.SNIPARA_MCP_URL || "${buildHostedMcpEndpoint(answers)}";
+const SNIPARA_API_KEY = process.env.SNIPARA_API_KEY;
+
+if (!SNIPARA_API_KEY) {
+  throw new Error("Missing SNIPARA_API_KEY");
+}
+
+async function callSniparaTool(toolName: string, args: Record<string, unknown>): Promise<string> {
+  const response = await fetch(SNIPARA_MCP_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": SNIPARA_API_KEY,
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: Date.now(),
+      method: "tools/call",
+      params: {
+        name: toolName,
+        arguments: args,
+      },
+    }),
+  });
+
+  const payload = (await response.json()) as { error?: unknown; result?: unknown };
+  if (!response.ok || payload.error) {
+    throw new Error("Snipara MCP call failed: " + JSON.stringify(payload.error || payload));
+  }
+
+  return JSON.stringify(payload.result || {});
+}
+
+export const sniparaRecallTool = tool(
+  async ({ query, type }) =>
+    callSniparaTool("snipara_recall", {
+      query,
+      ...(type ? { type } : {}),
+    }),
+  {
+    name: "snipara_recall",
+    description: "Recall durable Snipara decisions, preferences, and validated learnings.",
+    schema: z.object({
+      query: z.string().describe("Focused memory query."),
+      type: z.enum(["decision", "learning", "context", "preference"]).optional(),
+    }),
+  }
+);
+
+export const sniparaContextQueryTool = tool(
+  async ({ query, maxTokens }) =>
+    callSniparaTool("snipara_context_query", {
+      query,
+      max_tokens: maxTokens,
+      return_references: true,
+    }),
+  {
+    name: "snipara_context_query",
+    description: "Retrieve optimized source context, docs, runbooks, and source-truth references.",
+    schema: z.object({
+      query: z.string().describe("Question or task needing project context."),
+      maxTokens: z.number().int().positive().max(12000).default(4000),
+    }),
+  }
+);
+
+export const sniparaSettingsTool = tool(() => callSniparaTool("snipara_settings", {}), {
+  name: "snipara_settings",
+  description: "Validate the hosted Snipara MCP server and project settings.",
+  schema: z.object({}),
+});
+
+const beforeRequestHook = (req: Request): Request => {
+  const headers = new Headers(req.headers);
+  headers.set("X-Snipara-Client", "mistral-langchain");
+  return new Request(req, { headers });
+};
+
+const requestErrorHook = async (err: unknown, req: Request): Promise<void> => {
+  console.warn("Mistral request failed", { url: req.url, err });
+};
+
+const responseHook = async (res: Response, req: Request): Promise<void> => {
+  void req;
+  void res;
+};
+
+export const mistralWithSniparaTools = new ChatMistralAI({
+  model: process.env.MISTRAL_MODEL || "mistral-large-latest",
+  temperature: 0,
+  maxRetries: 2,
+  beforeRequestHooks: [beforeRequestHook],
+  requestErrorHooks: [requestErrorHook],
+  responseHooks: [responseHook],
+}).bindTools([sniparaRecallTool, sniparaContextQueryTool, sniparaSettingsTool]);
+`;
+}
 function buildGenericMcpReferenceTemplate(answers, client) {
   return `${JSON.stringify(
     {
@@ -1829,7 +2026,9 @@ function getClientGuidance(client) {
   if (client === "codex") {
     return [
       "Codex should use the hosted MCP surface plus AGENTS.md as the canonical project instruction file.",
-      "The generated .snipara/templates/codex-config.toml is a merge-ready snippet for ~/.codex/config.toml if your Codex app does not read project .codex/config.toml."
+      "The generated .snipara/templates/codex-config.toml is a merge-ready snippet for ~/.codex/config.toml if your Codex app does not read project .codex/config.toml.",
+      "Use SNIPARA_API_KEY as the only Codex bearer_token_env_var; restart Codex after changing MCP config.",
+      "If Codex lazily exposes only a minimal tool set, force discovery for snipara_recall, snipara_context_query, and snipara_settings; use snipara-companion as the fallback until Codex reloads."
     ];
   }
   if (client === "gemini") {
@@ -1838,6 +2037,14 @@ function getClientGuidance(client) {
       "Use .snipara/templates/gemini-mcp-reference.json as a field reference for the client's MCP settings."
     ];
   }
+  if (client === "mistral") {
+    return [
+      "Mistral Le Chat should use a Custom MCP Connector pointed at the hosted Snipara MCP endpoint.",
+      "Mistral Vibe should use .vibe/config.toml or ~/.vibe/config.toml with the generated streamable-http server block and AGENTS.md at the workspace root.",
+      "LangChain JavaScript can bind Snipara tools to ChatMistralAI with .snipara/templates/mistral-langchain-tools.ts.",
+      "Native lifecycle hooks are not claimed for Mistral; use snipara-companion for explicit recall, query, workflow, and task-commit flows."
+    ];
+  }
   if (client === "vscode") {
     return [
       "VS Code and Copilot-style clients should use Hosted MCP plus AGENTS.md for project workflow rules.",
@@ -2004,6 +2211,7 @@ function getClientDisplayName(client) {
     windsurf: "Windsurf",
     codex: "OpenAI Codex",
     gemini: "Gemini",
+    mistral: "Mistral Le Chat / Vibe",
     chatgpt: "ChatGPT / OpenAI MCP",
     vscode: "VS Code",
     continue: "Continue",
@@ -2019,6 +2227,7 @@ function getClientPackFilename(client) {
     windsurf: "WINDSURF.md",
     codex: "CODEX.md",
     gemini: "GEMINI.md",
+    mistral: "MISTRAL.md",
     chatgpt: "CHATGPT.md",
     vscode: "VSCODE.md",
     continue: "CONTINUE.md",
@@ -2043,6 +2252,15 @@ function getClientConfigArtifacts(client) {
   if (client === "gemini") {
     return ["AGENTS.md", ".snipara/templates/gemini-mcp-reference.json"];
   }
+  if (client === "mistral") {
+    return [
+      "AGENTS.md",
+      ".vibe/config.toml",
+      ".snipara/templates/mistral-vibe-config.toml",
+      ".snipara/templates/mistral-le-chat-mcp.json",
+      ".snipara/templates/mistral-langchain-tools.ts"
+    ];
+  }
   if (client === "vscode") {
     return ["AGENTS.md", ".snipara/templates/vscode-mcp-reference.json"];
   }
@@ -2480,6 +2698,12 @@ async function runValidation(answers, includeHostedCheck, options = {}) {
     status: detection.files.sniparaTemplates && detection.files.cursorRule && detection.files.codexConfig ? "pass" : "warn",
     detail: detection.files.sniparaTemplates && detection.files.cursorRule && detection.files.codexConfig ? ".snipara/templates, .cursor/rules/snipara.mdc, and .codex/config.toml present" : "Agent templates, Cursor rule, or Codex config missing"
   });
+  if (targetClient === "codex") {
+    checks.push(getCodexConfigCheck());
+  }
+  if (targetClient === "mistral") {
+    checks.push(getMistralConfigCheck());
+  }
   checks.push({
     name: "env_files",
     status: detection.files.env || detection.files.envLocal || detection.files.envExample ? "pass" : "warn",
@@ -2527,6 +2751,117 @@ function writeDoctorReport(report) {
   fs.writeFileSync(path.join(reportDir, "doctor.json"), JSON.stringify(report, null, 2) + "\n");
   console.log(chalk.green("   \u2713 Wrote .snipara/companion/doctor.json"));
 }
+function getCodexConfigCheck() {
+  const candidates = [
+    {
+      label: ".codex/config.toml",
+      filePath: path.join(process.cwd(), ".codex", "config.toml")
+    },
+    {
+      label: ".snipara/templates/codex-config.toml",
+      filePath: path.join(process.cwd(), ".snipara", "templates", "codex-config.toml")
+    },
+    {
+      label: "~/.codex/config.toml",
+      filePath: path.join(homedir(), ".codex", "config.toml")
+    }
+  ];
+  const present = candidates.filter((candidate) => fs.existsSync(candidate.filePath)).map((candidate) => ({
+    label: candidate.label,
+    content: fs.readFileSync(candidate.filePath, "utf-8")
+  }));
+  if (present.length === 0) {
+    return {
+      name: "codex_config",
+      status: "warn",
+      detail: "No Codex config found; merge .snipara/templates/codex-config.toml into ~/.codex/config.toml and restart Codex"
+    };
+  }
+  const configuredBearerEnvVars = present.flatMap(
+    (candidate) => Array.from(candidate.content.matchAll(/bearer_token_env_var\s*=\s*["']([^"']+)["']/g)).map(
+      (match) => ({
+        label: candidate.label,
+        value: match[1]
+      })
+    )
+  );
+  const usesSniparaEnv = configuredBearerEnvVars.some(
+    (candidate) => candidate.value === "SNIPARA_API_KEY"
+  );
+  const nonSniparaBearerEnvVars = configuredBearerEnvVars.filter(
+    (candidate) => candidate.value !== "SNIPARA_API_KEY"
+  );
+  const hasHostedEndpoint = present.some(
+    (candidate) => candidate.content.includes(`${API_URL}/mcp/`)
+  );
+  const labels = present.map((candidate) => candidate.label).join(", ");
+  if (nonSniparaBearerEnvVars.length > 0) {
+    const details = nonSniparaBearerEnvVars.map((candidate) => `${candidate.label} uses ${candidate.value}`).join("; ");
+    return {
+      name: "codex_config",
+      status: "warn",
+      detail: `Codex config uses a non-Snipara bearer env var (${details}); use SNIPARA_API_KEY and restart Codex`
+    };
+  }
+  if (!usesSniparaEnv || !hasHostedEndpoint) {
+    return {
+      name: "codex_config",
+      status: "warn",
+      detail: `Codex config found in ${labels}, but expected hosted MCP endpoint plus bearer_token_env_var = "SNIPARA_API_KEY"`
+    };
+  }
+  return {
+    name: "codex_config",
+    status: "pass",
+    detail: `Codex config uses hosted MCP and SNIPARA_API_KEY (${labels}); restart Codex after config changes`
+  };
+}
+function getMistralConfigCheck() {
+  const candidates = [
+    {
+      label: ".vibe/config.toml",
+      filePath: path.join(process.cwd(), ".vibe", "config.toml")
+    },
+    {
+      label: ".snipara/templates/mistral-vibe-config.toml",
+      filePath: path.join(process.cwd(), ".snipara", "templates", "mistral-vibe-config.toml")
+    },
+    {
+      label: "~/.vibe/config.toml",
+      filePath: path.join(homedir(), ".vibe", "config.toml")
+    }
+  ];
+  const present = candidates.filter((candidate) => fs.existsSync(candidate.filePath)).map((candidate) => ({
+    label: candidate.label,
+    content: fs.readFileSync(candidate.filePath, "utf-8")
+  }));
+  if (present.length === 0) {
+    return {
+      name: "mistral_config",
+      status: "warn",
+      detail: "No Mistral Vibe config found; use .snipara/templates/mistral-vibe-config.toml or add Snipara as a Le Chat Custom MCP Connector"
+    };
+  }
+  const hasHostedEndpoint = present.some(
+    (candidate) => candidate.content.includes(`${API_URL}/mcp/`)
+  );
+  const hasSniparaEnv = present.some(
+    (candidate) => candidate.content.includes('api_key_env = "SNIPARA_API_KEY"')
+  );
+  const labels = present.map((candidate) => candidate.label).join(", ");
+  if (!hasHostedEndpoint || !hasSniparaEnv) {
+    return {
+      name: "mistral_config",
+      status: "warn",
+      detail: `Mistral config found in ${labels}, but expected hosted MCP endpoint plus api_key_env = "SNIPARA_API_KEY"`
+    };
+  }
+  return {
+    name: "mistral_config",
+    status: "pass",
+    detail: `Mistral Vibe config uses hosted MCP and SNIPARA_API_KEY (${labels}); restart Vibe after config changes`
+  };
+}
 function printDoctorReport(detection, report) {
   const targetClient = report.checks.find((check) => check.name === "target_client")?.detail || detection.aiClient;
   console.log(chalk.bold("\n\u{1FA7A} Snipara Doctor\n"));
@@ -2572,16 +2907,22 @@ async function testHostedConnection(answers) {
     spinner.succeed("Connected to Snipara Hosted MCP.");
     const toolNames = extractMcpToolNames(toolsResponse.data);
     const hasSniparaTools = toolNames.some((name) => name.startsWith("snipara_"));
+    const advertisesLegacyTools = toolNames.some((name) => name.startsWith("rlm_"));
     const checks = [
       {
         name: "hosted_connection",
         status: "pass",
-        detail: "tools/list succeeded"
+        detail: "real tools/list succeeded"
       },
       {
-        name: "hosted_tool_aliases",
+        name: "hosted_snipara_tools",
         status: hasSniparaTools ? "pass" : "warn",
-        detail: hasSniparaTools ? "snipara_* tools are exposed by Hosted MCP" : "tools/list succeeded, but expected snipara_* tools were not detected"
+        detail: hasSniparaTools ? "snipara_* tools are advertised by Hosted MCP" : "tools/list succeeded, but expected snipara_* tools were not detected"
+      },
+      {
+        name: "hosted_legacy_tools_hidden",
+        status: advertisesLegacyTools ? "warn" : "pass",
+        detail: advertisesLegacyTools ? "tools/list still advertises legacy rlm_* tools; update or redeploy the hosted MCP surface" : "tools/list does not advertise legacy rlm_* duplicates"
       }
     ];
     const settingsTool = "snipara_settings";
@@ -2691,13 +3032,25 @@ function formatCheckStatus(check) {
 }
 function printSetupVerdict(answers, report) {
   const hostedConnection = getCheck(report, "hosted_connection");
-  const toolAliases = getCheck(report, "hosted_tool_aliases");
+  const sniparaTools = getCheck(report, "hosted_snipara_tools");
+  const legacyTools = getCheck(report, "hosted_legacy_tools_hidden");
+  const codexConfig = getCheck(report, "codex_config");
+  const mistralConfig = getCheck(report, "mistral_config");
   const claudeTools = getCheck(report, "claude_tools_visible");
   console.log(chalk.bold("\nSetup verdict:\n"));
   console.log(`   Config written: ${answers.profile !== "runtime-only" ? "OK" : "not requested"}`);
   console.log(`   Hosted MCP: ${formatCheckStatus(hostedConnection)}`);
-  if (toolAliases) {
-    console.log(`   Tool aliases: ${formatCheckStatus(toolAliases)}`);
+  if (sniparaTools) {
+    console.log(`   Snipara tools: ${formatCheckStatus(sniparaTools)}`);
+  }
+  if (legacyTools) {
+    console.log(`   Legacy tool duplicates: ${formatCheckStatus(legacyTools)}`);
+  }
+  if (codexConfig) {
+    console.log(`   Codex config: ${formatCheckStatus(codexConfig)}`);
+  }
+  if (mistralConfig) {
+    console.log(`   Mistral config: ${formatCheckStatus(mistralConfig)}`);
   }
   if (answers.aiClient === "claude-code" || answers.aiClient === "claude-desktop") {
     console.log(
@@ -2782,6 +3135,23 @@ function printSuccess(answers, report) {
     printNextStep(
       "For Codex, merge .snipara/templates/codex-config.toml into ~/.codex/config.toml if the app does not read project .codex/config.toml."
     );
+    printNextStep(
+      "Restart Codex after changing ~/.codex/config.toml so it rediscovers the hosted Snipara MCP tools."
+    );
+    printNextStep(
+      "If Codex shows only a minimal Snipara tool set, force discovery for snipara_recall, snipara_context_query, and snipara_settings."
+    );
+  }
+  if (answers.aiClient === "mistral") {
+    printNextStep(
+      "For Mistral Le Chat, add .snipara/templates/mistral-le-chat-mcp.json as a Custom MCP Connector reference in Connectors."
+    );
+    printNextStep(
+      "For Mistral Vibe, keep .vibe/config.toml or ~/.vibe/config.toml on the generated SNIPARA_API_KEY-backed streamable-http server block, then restart Vibe."
+    );
+    printNextStep(
+      "For LangChain JavaScript, adapt .snipara/templates/mistral-langchain-tools.ts to bind Snipara recall, context_query, and settings tools to ChatMistralAI."
+    );
   }
   printNextStep("Open .snipara/companion/README.md for local commands and repair flow.");
   printNextStep("Run create-snipara doctor anytime you want a fresh local validation report.");
@@ -2790,7 +3160,7 @@ function printSuccess(answers, report) {
       `${COMPANION_COMMAND_NAME} ${MIN_COMPANION_VERSION}+ is installed for low-latency local hooks.`
     );
     printNextStep(
-      `Use ${COMPANION_NPX_COMMAND} query / plan / upload / task-commit for explicit local workflows.`
+      `Use ${COMPANION_NPX_COMMAND} recall / query / plan / upload / task-commit for explicit local workflows and as a fallback when an AI client exposes only a partial MCP surface.`
     );
     printNextStep(
       `For business folders, preview with: ${COMPANION_NPX_COMMAND} onboard-folder ./client-export --source-provider local_folder --write-manifest ./snipara-onboard.json`
@@ -2877,6 +3247,7 @@ function detectEnvironment() {
       claudeProjectSettings: fs.existsSync(path.join(process.cwd(), ".claude", "settings.json")),
       claudeDesktopConfig: fs.existsSync(claudePaths.desktopConfigPath),
       cursorDir: fs.existsSync(path.join(homedir(), ".cursor")),
+      mistralVibeConfig: fs.existsSync(path.join(process.cwd(), ".vibe", "config.toml")) || fs.existsSync(path.join(homedir(), ".vibe", "config.toml")),
       sniparaCompanionPack: fs.existsSync(path.join(process.cwd(), ".snipara", "companion")),
       sniparaTemplates: fs.existsSync(path.join(process.cwd(), ".snipara", "templates"))
     },
@@ -2981,6 +3352,16 @@ function collectConfiguredProjectSlugSignals(existingConfig = getExistingConfig(
         path.join(process.cwd(), ".snipara", "templates", "codex-config.toml")
       )
     },
+    {
+      source: ".vibe/config.toml",
+      slug: readProjectSlugFromTextFile(path.join(process.cwd(), ".vibe", "config.toml"))
+    },
+    {
+      source: ".snipara/templates/mistral-vibe-config.toml",
+      slug: readProjectSlugFromTextFile(
+        path.join(process.cwd(), ".snipara", "templates", "mistral-vibe-config.toml")
+      )
+    },
     { source: ".env.local", slug: readProjectSlugFromEnvFile(".env.local") },
     { source: ".env", slug: readProjectSlugFromEnvFile(".env") }
   ];
@@ -3186,6 +3567,9 @@ function detectAiClient() {
   if (fs.existsSync(path.join(process.cwd(), ".gemini"))) {
     return "gemini";
   }
+  if (fs.existsSync(path.join(process.cwd(), ".vibe"))) {
+    return "mistral";
+  }
   if (fs.existsSync(path.join(process.cwd(), ".continue"))) {
     return "continue";
   }
@@ -3204,6 +3588,9 @@ function detectAiClient() {
   if (fs.existsSync(path.join(homedir(), ".gemini")) || process.env.GEMINI_CLI) {
     return "gemini";
   }
+  if (fs.existsSync(path.join(homedir(), ".vibe")) || process.env.MISTRAL_VIBE) {
+    return "mistral";
+  }
   if (fs.existsSync(path.join(homedir(), ".continue")) || process.env.CONTINUE_GLOBAL_DIR) {
     return "continue";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-snipara",
-  "version": "1.3.39",
+  "version": "1.3.41",
   "description": "Onboard Snipara Hosted MCP Context + Memory with auth, companion workflows, and optional Snipara Sandbox",
   "main": "dist/index.js",
   "type": "module",
@@ -34,6 +34,7 @@
     "cursor",
     "windsurf",
     "gemini",
+    "mistral",
     "vscode",
     "continue",
     "claude-desktop"