@dotdrelle/wiki-manager 0.15.34 → 0.15.38

package/.env.example

@@ -57,12 +57,15 @@ CONNECTORS_MCP_AUTH_TOKEN=
 CONNECTORS_ENABLED=false
 #
 # The wikiLLM Google OAuth application is baked into the agent-connectors image
-# at build time, from agent-external/agent-connectors/.env.build.local. When you
-# build the image locally, that file must exist — otherwise the container starts
-# with empty credentials.
-# Optional runtime override (no rebuild needed):
+# at build time, from agent-external/agent-connectors/.env.build.local. Neither
+# value is a security boundary (public Desktop-type client); baking them is what
+# makes the connector work out of the box.
+#
+# Set either key below to use YOUR OWN Google application instead — it overrides
+# the baked default at runtime, no rebuild needed. LEAVE THEM COMMENTED to keep
+# the baked one: an empty value here is forwarded as an empty value and disables
+# the client entirely.
 # GOOGLE_OAUTH_CLIENT_ID=
-# Optional confidential-client compatibility override:
 # GOOGLE_OAUTH_CLIENT_SECRET=
 #
 # The callback URL is generated automatically

package/README.md

@@ -556,6 +556,48 @@ including under `"*"`. Multi-step work belongs to `/agent`.
 An `allowActions` key written by an older manager is folded into `allow` on
 read and removed on the next `agents up`.
 
+### Adding a connector from the served chat UI
+
+`mcp.endpoints.json` stays hand-editable, but the Connectors panel of
+`llm-wiki serve` can now write it. Connecting a card there upserts the endpoint
+through the runtime (`POST /mcp/endpoints`), and the runtime immediately
+re-reads the file and rediscovers tools and agents — no restart, and the new
+tools are usable in the same breath by `/chat`, `/agent` and any subsequent
+plan.
+
+Because a server absent from `chatAccess` gets **zero** tools in `/chat`, the
+upsert writes `"allow": "*"` for it. That is the deliberate difference between
+a connector declared by hand — where you choose the tool list — and one added
+from the UI, where the person adding it is the person who will use it. Narrow
+it afterwards by editing the file.
+
+Three origins are distinguished, and the UI labels each card:
+
+| origin | shown as | who owns it |
+| --- | --- | --- |
+| `wiki`, `production`, `llm-wiki`, `wiki-production` | `internal` | the workspace stack. Fields read-only, no delete — the runtime rejects any change to these names |
+| declared in `mcp.endpoints.json` by hand or by `agents up` | `global config` | the operator. CME, Documents, Mailer, Connectors, Exa… |
+| added from the UI | `added here` | carries `"managedBy": "serve-ui"` in the file |
+
+Removing a `global config` connector is a workspace-wide act — it leaves every
+chat, agent and future plan — so the UI says so before confirming. The
+container and its data are untouched; only the wiring is removed. The name is
+also pushed into `disabledMcpServers`, which the scaffold honours, so a
+connector you removed on purpose is not silently restored by the next
+`agents up` merging the packaged example back in.
+
+Renaming is atomic: the UI sends `previousName`, and the endpoint, its
+`Authorization` header and its `chatAccess` entry move together under the new
+key. A rename onto an existing name, or from a name that is not there, is
+rejected rather than half-applied.
+
+`POST /mcp/endpoints` returns **409 while a plan is running** — connector
+wiring must not change under a run that already resolved its agents. The chat
+UI treats that as what it is: the MCP handshake succeeded, so the card stays
+connected and usable in this browser, badged `local only` with
+"runtime synchronization pending", and the write is retried on the next
+reconnect. A busy runtime never presents itself as a broken connector.
+
 MCP `tools/call` requests retry transient HTTP/MCP failures before the run fails.
 They also share a per-endpoint outbound control budget (45 RPM by default,
 configurable with `WIKI_MANAGER_MCP_REQUESTS_PER_MINUTE`). This budget is

package/agents.docker-compose.yml

@@ -94,22 +94,13 @@ services:
 
   connectors:
     profiles: [connectors]
-    # Local iteration: build the image from the connectors repo instead of
-    # pulling the published tag. `image:` is kept so the build is tagged with the
-    # same name; restore image-only before publishing a release.
-    build:
-      context: ../agent-external/agent-connectors
-      dockerfile: Dockerfile
-      args:
-        # Without these the ARGs stay unset and the image ships empty
-        # WIKILLM_GOOGLE_OAUTH_* values, so the container ends up with no Google
-        # client at all. `wiki-workspace agents up` exports them from the
-        # connectors repo's .env.build.local before invoking Compose.
-        # Deliberately value-less: Compose then forwards each host variable only
-        # when it is defined. Never write `${VAR:-}` here — an empty
-        # --build-arg pins the ARG to the empty string.
-        WIKILLM_GOOGLE_OAUTH_CLIENT_ID:
-        WIKILLM_GOOGLE_OAUTH_CLIENT_SECRET:
+    # Image only, jamais de `build:` ici. Ce fichier est livré dans le paquet
+    # npm, où le dépôt agent-connectors n'existe pas : un contexte de build
+    # pointant vers `../agent-external/…` y est irrésolvable. La construction
+    # appartient à `build-and-push.sh`, qui cuit l'application OAuth wikiLLM
+    # dans l'image publiée. Pour utiliser sa propre application Google, on
+    # surcharge GOOGLE_OAUTH_CLIENT_ID / _SECRET dans le .env du manager — sans
+    # reconstruire quoi que ce soit.
     image: dotdrelle/agent-connectors:latest
     user: "${UID:-1000}:${GID:-1000}"
     ports:
@@ -119,6 +110,10 @@ services:
       - MCP_AUTH_TOKEN=${CONNECTORS_MCP_AUTH_TOKEN:-}
       - WORKSPACES_ROOT=/workspaces
       - AGENT_DATA_DIR=/data
+      # Vides par défaut, et c'est sans conséquence : l'application OAuth
+      # embarquée dans l'image est lue depuis un fichier, pas depuis
+      # l'environnement. Renseigner l'une de ces deux clés dans le .env du
+      # manager la fait gagner sur la valeur embarquée.
       - GOOGLE_OAUTH_CLIENT_ID=${GOOGLE_OAUTH_CLIENT_ID:-}
       - GOOGLE_OAUTH_CLIENT_SECRET=${GOOGLE_OAUTH_CLIENT_SECRET:-}
       - GOOGLE_OAUTH_CALLBACK_URL=${GOOGLE_OAUTH_CALLBACK_URL:-}

package/docker-compose.yml

@@ -144,13 +144,14 @@ x-wiki-manager:
       description: "Full workspace service set."
     ui:
       targets: [serve]
-      description: "Alias for serve: workspace web UI."
-    wiki:
-      targets: [mcp-http]
-      description: "Alias for mcp-http: wiki MCP server."
-    mcp:
-      targets: [mcp-http]
-      description: "Alias for mcp-http: wiki MCP server."
+      description: "Chat, wiki browser and Donna's web UI."
+    # Pas d'alias `wiki` ici : ce nom est deja celui d'un service Compose (le
+    # CLI one-shot de `/wiki run`). L'alias le masquait, et `/start wiki`
+    # demarrait mcp-http sans le dire.
+    #
+    # Pas d'alias `mcp` non plus : mcp-http fait partie du socle demarre par
+    # `all` et `services`, personne ne le demarre seul. Il reste adressable
+    # sous son nom Compose.
     production:
       targets: [production-mcp]
-      description: "Alias for production-mcp: production jobs."
+      description: "Ingest, build, export and polish jobs."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.34",
+  "version": "0.15.38",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "start": "bun ./bin/wiki-manager.js",
-    "test": "node --test src/cli/runtimeStartup.test.js src/cli/wiki-manager.test.js src/agent/graph.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/env.test.js src/core/agentsCompose.test.js src/core/buildInfo.test.js src/core/agentEvents.test.js src/core/runtimeLog.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.test.js src/core/workflow.test.js src/core/planPatch.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/toolLoop.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/wikiSetup.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/cacert.test.js src/core/composeOverrides.test.js src/core/setEnvValue.test.js src/core/commandFailure.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/orchestrator/dispatcher.test.js src/orchestrator/objectiveResolver.test.js src/commands/slash.test.js src/shell/repl.test.js src/shell/setupWizardPlaceholders.test.js src/shell/setupWizardSuggestions.test.js src/runtime/store.test.js src/runtime/controlMessages.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/donna-contract.test.js src/runtime/auth.test.js",
+    "test": "node --test src/cli/runtimeStartup.test.js src/cli/wiki-manager.test.js src/agent/graph.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/env.test.js src/core/agentsCompose.test.js src/core/profileServiceStatus.test.js src/core/buildInfo.test.js src/core/agentEvents.test.js src/core/runtimeLog.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.test.js src/core/workflow.test.js src/core/planPatch.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/toolLoop.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/wikiSetup.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/cacert.test.js src/core/composeOverrides.test.js src/core/setEnvValue.test.js src/core/commandFailure.test.js src/core/googleGrants.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/orchestrator/dispatcher.test.js src/orchestrator/objectiveResolver.test.js src/commands/slash.test.js src/shell/repl.test.js src/shell/setupWizardPlaceholders.test.js src/shell/setupWizardSuggestions.test.js src/shell/setupWizardDiscovery.test.js src/shell/wrapText.test.js src/runtime/lifecycle.test.js src/runtime/store.test.js src/runtime/controlMessages.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/donna-contract.test.js src/runtime/auth.test.js",
     "check-versions": "node scripts/check-versions.js",
     "prepack": "node scripts/check-versions.js",
     "prepublishOnly": "node scripts/check-versions.js",

package/src/agent/graph.js

@@ -1019,12 +1019,32 @@ export function buildAgentSystemPrompt(state) {
       ? 'The runtime is connected and runtime__delegate is available for any requested capability action that has no matching direct tool. When a matching direct tool is offered, call it directly; otherwise let the runtime resolve the objective from discovered capability contracts.'
       : 'No runtime is connected, so you cannot execute actions. State that plainly and name the runtime connection as the missing capability — do not invent a workaround.',
     'If the connector or service needed for a requested read or action is absent from the Connected MCP tools above (its service is not running — e.g. CME, documents, or production), say plainly that this service is not connected and name it as the missing capability. Never redirect a simple read (e.g. "give me the CME config") to an "agent action", never invent its result, and never propose a workaround. Only requests you can actually serve with a listed tool are answered with data.',
+    // Cas observé : « récupère ce mail » et « envoie un mail » refusés comme
+    // impossibles, alors que l'agent connectors déclare `external-source.collect`
+    // (écrit dans raw/untracked/) et `communication.send-email`. Les outils de
+    // lecture directs ne rendent que des métadonnées : les prendre pour la
+    // limite de l'agent transforme un travail délégable en refus.
+    'The direct read tools of a connector are a preview, not the measure of what its agent can do. Bringing external content INTO the workspace (retrieve, import, fetch, save, "récupère") is a collect capability, and acting on the outside world (send, publish, notify) is an action capability: both are delegated through runtime__delegate, not answered from a read tool. Never conclude that something is impossible because the listed read tool returns only metadata — check the capabilities the agents declare, and delegate the objective as stated.',
+    // Un droit manquant n'est pas une fonctionnalité absente : l'un se
+    // réautorise en une commande, l'autre n'existe pas. Les confondre envoie
+    // l'utilisateur croire que le produit ne sait pas faire.
+    'When an action fails or is refused for lack of an authorization grant or scope (rather than a missing capability), say exactly that and name the primitive that grants it. Do not describe the feature as unavailable.',
     'For an action with no matching direct tool, call runtime__delegate with the user objective only. The runtime chooses the capability, operation, agent and plan, including a validated single task for executor-only agents. Never choose those identifiers yourself. Never call <provider>__agent_plan, <provider>__agent_execute, legacy production__production_start_job, wiki__plan_set, or wiki__plan_done from interactive chat.',
     'Do not ask the user which sources, files, connectors, or templates to use for an ingest, build, or export: the specialized agent discovers them from the workspace. When the objective is clear (e.g. "lance une ingestion"), delegate it as stated, without a clarifying question.',
     'Promise only what the resolved capability actually exposes in its declared contract (the input schema the specialized agent publishes for that capability). When the user requests an execution parameter — a batch or chunk size, a count "N at a time", concurrency, ordering, priority, or any tuning knob — apply it only if that parameter exists in the target capability\'s published input schema. Otherwise do not confirm or promise it: delegate the objective, and if the user explicitly asked for that parameter, say plainly in one line that you started the work but do not control that aspect (the runtime and the specialized agent decide it). Never state or imply a parameter was applied when the agent contract cannot enforce it.',
     'If runtime__delegate returns a blocker or no specialized provider is available, report only that concrete blocker concisely. Never replace the missing execution path with a suggested slash command, skill, MCP tool name, manual file move, administrator escalation, or alternative workflow unless the user explicitly asks for alternatives.',
     'For workspace inventory and page listings, use the connected wiki MCP read tools. Never invent or call a /wiki shell command through shell__run_command. Use /workspace init <name> [path] for low-level non-interactive workspace creation; in the interactive TUI, /new <name> opens the setup wizard.',
     'If an action requires tools or skills not available yet, explain the limitation and name the expected primitive.',
+    // Les outils help_* étaient exposés — ils font partie de l'allow-list du
+    // mode chat — mais rien dans ce prompt ne disait qu'ils sont LA source des
+    // questions produit. Donna répondait donc de mémoire. Cas observé :
+    // « comment activer les connecteurs ? » → un `cme.yaml`, un « manifeste des
+    // services actifs » et un redémarrage de service, tous inventés, là où la
+    // réponse tient dans un drapeau du `.env` du manager.
+    'The bundled product documentation is your source for how llm-wiki works: what a feature is, how to enable or configure it, where a setting lives, what a message means, how to get started, how to troubleshoot. For any such question, call the documentation search/read tools FIRST and answer from what they return. Do not answer these from memory, even when you feel certain.',
+    // Une réponse fausse et assurée sur la configuration coûte plus cher qu'un
+    // « je ne sais pas » : elle envoie éditer des fichiers qui n'existent pas.
+    'Configuration facts are never answered from memory. File names, environment variables, config keys, directory layouts and enabling procedures must come from a tool result or from the documentation you actually read in this conversation. If the documentation does not cover it, say plainly that you could not find where it is configured — never reconstruct a plausible-looking file name, key or procedure. A confident wrong answer sends the user editing files that do not exist.',
     workspaceProfile
       ? `Workspace profile (.wiki/profile.md) — durable user preferences, apply these to every reply (tone, tutoiement/vouvoiement, formatting, etc.):\n${workspaceProfile}`
       : null,

package/src/cli/wiki-manager.js

@@ -14,6 +14,7 @@ import { refreshRunningContainers } from '../core/wikiSetup.js';
 import { applySessionWikircProfile } from '../core/sessionConfig.js';
 import { listWikircProfiles } from '../core/wikirc.js';
 import { callMcpTool, formatMcpToolResult, readChatAccessConfig } from '../core/mcp.js';
+import { deleteManagedMcpEndpoint, listManagedMcpEndpoints, upsertManagedMcpEndpoint } from '../core/mcpEndpoints.js';
 import { extractActivity, parseJsonText, sessionActivities, terminalFailures } from '../core/activity.js';
 import { syncActivitiesToPlan, formatPlanStatus } from '../core/plan.js';
 import { createAgentEvent, dispatchAgentEvent, reduceAgentEvents } from '../core/agentEvents.js';
@@ -740,6 +741,14 @@ async function runRuntime(argv, agent) {
   let serverHandle = null;
   const contexts = new Map();
 
+  async function refreshAllMcpContexts() {
+    const resolved = await Promise.all([...new Set(contexts.values())].map((value) => Promise.resolve(value)));
+    await Promise.all(resolved.map(async (context) => {
+      await refreshMcpRuntimeStatus(context.session);
+      await discoverAgentsOnce(context.session);
+    }));
+  }
+
   async function getWorkspaceContext(workspaceName = null) {
     const requestedWorkspace = workspaceName ? String(workspaceName).trim() : null;
     const key = requestedWorkspace ?? '__default__';
@@ -1416,6 +1425,17 @@ async function runRuntime(argv, agent) {
         config,
       };
     },
+    listMcpEndpoints: async () => ({ endpoints: listManagedMcpEndpoints() }),
+    upsertMcpEndpoint: async (_context, body) => {
+      const endpoint = upsertManagedMcpEndpoint(body);
+      await refreshAllMcpContexts();
+      return { ok: true, endpoint };
+    },
+    deleteMcpEndpoint: async (_context, body) => {
+      const endpoint = deleteManagedMcpEndpoint(body.name);
+      await refreshAllMcpContexts();
+      return { ok: true, endpoint };
+    },
     token: auth.token,
   });
   const recovery = await recoverRuntime();

package/src/commands/slash.js

@@ -3,6 +3,8 @@ import { openExternalUrl } from '../shell/openExternal.js';
 import { classifyCommandFailure, failureHint, rawFailureText } from '../core/commandFailure.js';
 import { join, relative } from 'node:path';
 import { composeServices, listServices, runWikiCli, serviceLogs, serviceNames, serviceStates, startService, stopService } from '../core/compose.js';
+import { agentServiceNames, profileServiceStatus } from '../core/agentsCompose.js';
+import { GOOGLE_GRANTS, GOOGLE_GRANT_LABELS, defaultGoogleGrants } from '../core/googleGrants.js';
 import {
   applyMcpRuntimeStatus,
   buildMcpStatus,
@@ -336,7 +338,7 @@ function workspaceStatsColumns(stats, session) {
   };
 }
 
-function workspaceLoadedText(workspace, summary, session) {
+function workspaceLoadedText(workspace, summary, session, mcpError = null) {
   const profiles = listWikircProfiles(workspace.workspacePath);
   const profileLines = profiles.length > 0
     ? profiles.map((profile) => {
@@ -372,6 +374,7 @@ function workspaceLoadedText(workspace, summary, session) {
     '',
     `llm: ${session.llm ? 'configured' : 'missing config'}`,
     `mcp: ${Object.values(session.mcp ?? {}).filter((value) => value.status === 'connected').length} connected`,
+    ...(mcpError ? ['', `MCP discovery failed: ${mcpError}`] : []),
   ].join('\n');
 }
 
@@ -939,9 +942,17 @@ export async function handleSlashCommand(line, context) {
       context.session.workspaceEnv = workspace.env;
       context.session.workspaceEnvFile = workspace.envFile;
       context.session.systemPrompt = loadWorkspaceSystemPrompt(workspace.workspacePath);
+      let summary;
       try {
         step(`Workspace: loading ${workspace.name} config…`);
-        const { summary } = applySessionWikircProfile(context.session, 'default');
+        ({ summary } = applySessionWikircProfile(context.session, 'default'));
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          output: workspaceLoadedWithoutConfigText(workspace, message),
+        };
+      }
+      try {
         step(`Workspace: discovering ${workspace.name} MCP tools…`);
         await refreshMcpRuntimeStatus(context.session);
         return {
@@ -950,7 +961,7 @@ export async function handleSlashCommand(line, context) {
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return {
-          output: workspaceLoadedWithoutConfigText(workspace, message),
+          output: workspaceLoadedText(workspace, summary, context.session, message),
         };
       }
     }
@@ -1058,6 +1069,12 @@ export async function handleSlashCommand(line, context) {
       // falls back to the hardcoded COMPOSE_SERVICES constant instead.
       const service = args[1];
       if (service === 'agents' || service === 'agent') return runAgentCommand(startAgents, 'start');
+      // Un agent nommé appartient à la pile agents (projet Compose distinct),
+      // pas à celle du workspace : le router ici évite un « no such service »
+      // sur un nom que la complétion propose pourtant.
+      if (agentServiceNames().includes(service)) {
+        return runAgentCommand((options) => startAgents({ ...options, services: [service] }), 'start');
+      }
       // "all" used to mean "the workspace services", which left the external
       // agents down and looked like nothing had happened. It now means what an
       // operator reads into it: the whole stack. `/start services` keeps the
@@ -1094,9 +1111,22 @@ export async function handleSlashCommand(line, context) {
     case 'stop': {
       const service = args[1];
       if (service === 'agents') return runAgentCommand(stopAgents, 'stop');
+      if (agentServiceNames().includes(service)) {
+        return runAgentCommand((options) => stopAgents({ ...options, services: [service] }), 'stop');
+      }
+      // Symétrique de `/start all` : « all » désigne toute la pile, agents
+      // compris. Il ne stoppait que les services du workspace et laissait les
+      // agents debout — donc `/start all` puis `/stop all` ne revenait pas à
+      // l'état de départ.
+      const stopsAgents = service === 'all';
+      const stopTarget = service === 'services' ? undefined : service;
       try {
         step(`Services: stopping ${service ?? 'workspace services'}…`);
-        await stopService(context.session, service);
+        await stopService(context.session, stopTarget);
+        if (stopsAgents) {
+          const agentsResult = await runAgentCommand(stopAgents, 'stop');
+          if (agentsResult?.failed) return agentsResult;
+        }
         step('Services: refreshing MCP runtime…');
         await refreshMcpRuntimeStatus(context.session);
         return localizedOperationResult({
@@ -1186,7 +1216,9 @@ export async function handleSlashCommand(line, context) {
       await refreshMcpRuntimeStatus(context.session);
       const connectorMcp = context.session.mcp?.connectors;
       if (!connectorMcp || connectorMcp.status !== 'connected') {
-        return connectorResult('The connectors service is unavailable or disabled.');
+        // Le manager sait exactement pourquoi : ne pas renvoyer un constat
+        // vague que Donna comblerait en inventant.
+        return connectorResult(profileServiceStatus('connectors').message);
       }
       if (subcommand === 'list') {
         if (args[2]) return connectorResult('The connector list request has invalid extra arguments.');
@@ -1198,38 +1230,78 @@ export async function handleSlashCommand(line, context) {
             { workspace: context.session.workspace },
           );
           const payload = parseJsonText(formatMcpToolResult(result));
-          const status = payload?.status === 'configured' ? 'authorized' : 'not authorized';
-          return connectorResult(`google (Gmail read-only): ${status}`);
+          if (payload?.status !== 'configured') {
+            return connectorResult('google (Gmail): not authorized. Run `/connector auth google` to authorize reading and sending.');
+          }
+          // Le libellé annonçait « read-only » quels que soient les droits
+          // réellement accordés — donc il mentait dès qu'on autorisait l'envoi,
+          // et n'aidait pas à comprendre pourquoi l'envoi échouait sinon.
+          const grants = Array.isArray(payload?.grants) ? payload.grants : [];
+          const missing = GOOGLE_GRANTS.filter((grant) => !grants.includes(grant));
+          const held = grants.map((grant) => `${grant} — ${GOOGLE_GRANT_LABELS[grant] ?? 'unknown grant'}`);
+          const lines = [
+            `google (Gmail): authorized for ${grants.join(', ') || 'nothing'}`,
+            ...held.map((line) => `  ✓ ${line}`),
+            ...missing.map((grant) => `  ✗ ${grant} — ${GOOGLE_GRANT_LABELS[grant]}`),
+          ];
+          if (missing.length > 0) {
+            lines.push(`Run \`/connector auth google ${missing.join(' ')}\` to add the missing grant(s); existing ones are kept.`);
+          }
+          return connectorResult(lines.join('\n'));
         } catch (err) {
-          return connectorResult(`google (Gmail read-only): unavailable (${err instanceof Error ? err.message : String(err)})`);
+          return connectorResult(`google (Gmail): unavailable (${err instanceof Error ? err.message : String(err)})`);
         }
       }
       if (subcommand === 'auth') {
         const connector = String(args[2] ?? '').toLowerCase();
         if (!['google', 'gmail'].includes(connector)) {
-          return connectorResult('The requested connector is unsupported. The available connector is google (Gmail read-only).');
+          return connectorResult('The requested connector is unsupported. The available connector is google (Gmail).');
+        }
+        // Les droits demandés à Google. L'appel ne les passait pas, et le
+        // serveur retombait sur son défaut `["read"]` : l'agent sait envoyer un
+        // courriel, l'autorisation obtenue ne le permettait pas, et le refus
+        // ressemblait à une fonctionnalité absente. On demande donc lecture ET
+        // envoi par défaut, et les droits restants s'ajoutent à la demande.
+        const requested = args.slice(3).map((value) => String(value).toLowerCase());
+        const unknown = requested.filter((grant) => !GOOGLE_GRANTS.includes(grant));
+        if (unknown.length > 0) {
+          const available = GOOGLE_GRANTS.map((grant) => `${grant} (${GOOGLE_GRANT_LABELS[grant]})`).join('; ');
+          return connectorResult(`Unsupported grant(s): ${unknown.join(', ')}. Available grants: ${available}.`);
         }
+        // Par défaut, tout ce que l'agent sait faire — y compris `modify`, sans
+        // quoi les actions que Donna propose d'elle-même (« marquer comme lu »,
+        // « archiver ») échouent après coup. C'est la même incohérence que
+        // l'envoi : promettre une action que l'autorisation ne couvre pas.
+        const grants = requested.length > 0 ? [...new Set(requested)] : defaultGoogleGrants();
         try {
           const result = await callMcpTool(
             context.session.mcp,
             'connectors',
             'connectors_google_oauth_start',
-            { workspace: context.session.workspace },
+            { workspace: context.session.workspace, grants },
           );
           const payload = parseJsonText(formatMcpToolResult(result));
           const authorizationUrl = payload?.authorizationUrl;
+          if (payload?.error === 'send_capability_disabled') {
+            return connectorResult(
+              'Sending is disabled in this deployment (CONNECTORS_SEND_ENABLED=false in the manager .env), so the send grant cannot be authorized. Run `/connector auth google read` for read-only access, or enable sending and restart the connectors agent.',
+            );
+          }
           if (payload?.ok !== true || typeof authorizationUrl !== 'string') {
             return connectorResult(`Google authorization could not start (${payload?.error ?? 'missing authorization URL'}).`);
           }
+          // L'autorisation est incrémentale côté Google : redemander avec un
+          // droit de plus ne révoque pas les précédents.
+          const scopeNote = `Requested grants: ${grants.join(', ')}.`;
           if (openExternalUrl(authorizationUrl)) {
-            return connectorResult('Google authorization opened successfully in the user browser.');
+            return connectorResult(`Google authorization opened successfully in the user browser. ${scopeNote}`);
           }
-          return connectorResult(`Google authorization requires the user to open this URL: ${authorizationUrl}`);
+          return connectorResult(`Google authorization requires the user to open this URL: ${authorizationUrl} — ${scopeNote}`);
         } catch (err) {
           return connectorResult(`Google authorization could not start (${err instanceof Error ? err.message : String(err)}).`);
         }
       }
-      return connectorResult('The requested connector action is unsupported. Available actions: list and auth google.');
+      return connectorResult(`The requested connector action is unsupported. Available actions: list, and auth google [${GOOGLE_GRANTS.join('|')}].`);
     }
     case 'cancel': {
       // Alias of /run cancel — people type /cancel when they want out.

package/src/commands/slash.test.js

@@ -126,9 +126,43 @@ test('/start completes to the three documented targets', async () => {
   for (const expected of ['all', 'agents', 'services']) {
     assert.ok(matches.includes(expected), `${expected} missing from ${JSON.stringify(matches)}`);
   }
-  assert.match(completionDescription('all', ['/start']), /services AND the external agents/);
-  assert.match(completionDescription('agents', ['/start']), /agents only/);
-  assert.match(completionDescription('services', ['/start']), /workspace services only/);
+  assert.match(completionDescription('all', ['/start']), /services AND external agents/);
+  assert.match(completionDescription('agents', ['/start']), /agents only/i);
+  assert.match(completionDescription('services', ['/start']), /workspace services only/i);
+});
+
+test('/start offers the operator vocabulary, not the Compose service names twice', async () => {
+  const { completionDescription } = await import('../shell/repl.js');
+  const { matches } = completionContext('/start ', {});
+
+  // `all` apparaissait deux fois — mot-clé du shell ET alias Compose — et
+  // chaque alias était doublé du service qu'il désigne : dix entrées pour cinq
+  // actions.
+  assert.equal(new Set(matches).size, matches.length, `duplicates in ${JSON.stringify(matches)}`);
+  for (const raw of ['serve', 'mcp-http', 'production-mcp']) {
+    assert.ok(!matches.includes(raw), `${raw} is already covered by an alias`);
+  }
+  for (const alias of ['ui', 'production']) {
+    assert.ok(matches.includes(alias), `${alias} missing from ${JSON.stringify(matches)}`);
+    assert.notEqual(
+      completionDescription(alias, ['/start']),
+      'Start this Docker Compose service.',
+      `${alias} must explain what it starts`,
+    );
+  }
+  // `wiki` est le service one-shot de `/wiki run` : en faire un alias de
+  // mcp-http le masquait silencieusement.
+  assert.ok(!matches.includes('wiki'), 'wiki must not shadow the one-shot CLI service');
+  // mcp-http fait partie du socle demarre par `all` et `services` : son alias
+  // n'ajoutait qu'une ligne a lire pour un service que personne ne lance seul.
+  assert.ok(!matches.includes('mcp'), 'mcp is covered by services/all');
+  // Les agents du socle ne s'adressent pas un par un, et `mailer` n'existe
+  // meme pas tant qu'il n'est pas decommente dans l'override de l'operateur.
+  for (const agent of ['cme', 'documents', 'mailer']) {
+    assert.ok(!matches.includes(agent), `${agent} is started by "agents", not on its own`);
+  }
+  // Seuls les agents derriere un drapeau de profil se pilotent separement.
+  assert.ok(matches.includes('connectors'), 'connectors is opt-in, so it must be addressable');
 });
 
 test('/workspace delete removes files and clears current session context after confirmation', async () => {
@@ -311,6 +345,54 @@ test('/use loads only workspaces and /config use switches wikirc profiles', asyn
   }
 });
 
+test('/use keeps a loaded wikirc when MCP discovery fails', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'wiki-manager-use-mcp-error-'));
+  const registryRoot = join(root, 'registry');
+  const workspacePath = join(root, 'workspace');
+  const registryPath = join(registryRoot, 'demo');
+  mkdirSync(registryPath, { recursive: true });
+  mkdirSync(workspacePath, { recursive: true });
+  mkdirSync(join(root, 'mcp.endpoints.json'));
+  writeFileSync(join(root, '.env'), '', 'utf8');
+  writeFileSync(join(registryPath, '.env'), [
+    'WORKSPACE_NAME=demo',
+    `WIKI_WORKSPACE_PATH=${workspacePath}`,
+    '',
+  ].join('\n'), 'utf8');
+  writeFileSync(join(workspacePath, '.wikirc.yaml'), [
+    'language: fr',
+    'llm:',
+    '  provider: openai-compatible',
+    '  engine: openai',
+    '  model: test-model',
+    '  apiKey: test-key',
+    '',
+  ].join('\n'), 'utf8');
+
+  const previousDir = process.env.WIKI_WORKSPACES_DIR;
+  const previousEnvFile = process.env.WIKI_MANAGER_ENV_FILE;
+  process.env.WIKI_WORKSPACES_DIR = registryRoot;
+  process.env.WIKI_MANAGER_ENV_FILE = join(root, '.env');
+  try {
+    const session = {};
+    const result = await handleSlashCommand('/use demo', {
+      packageJson: { version: 'test' },
+      session,
+    });
+
+    assert.equal(session.wikirc?.profile, 'default');
+    assert.equal(session.wikircConfig?.llm?.model, 'test-model');
+    assert.match(result.output ?? '', /profile: default/);
+    assert.match(result.output ?? '', /MCP discovery failed:.*EISDIR/s);
+    assert.doesNotMatch(result.output ?? '', /Wikirc not loaded/);
+  } finally {
+    if (previousDir === undefined) delete process.env.WIKI_WORKSPACES_DIR;
+    else process.env.WIKI_WORKSPACES_DIR = previousDir;
+    if (previousEnvFile === undefined) delete process.env.WIKI_MANAGER_ENV_FILE;
+    else process.env.WIKI_MANAGER_ENV_FILE = previousEnvFile;
+  }
+});
+
 test('/queue cancel refuses runtime-managed items instead of fake-cancelling locally', async () => {
   // syncRuntimeState replaces session.jobQueue with the runtime queue and tags
   // origin:'runtime' — a local cancel would be reverted by the next SSE sync,

package/src/core/agentsCompose.js

@@ -1,5 +1,6 @@
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import YAML from 'yaml';
 
 import { managerComposeOverrideFile, managerEnvFile, readEnvFile } from './env.js';
 import { managerRoot } from './workspaces.js';
@@ -16,10 +17,94 @@ export const PROFILE_FLAGS = Object.freeze({
   connectors: 'CONNECTORS_ENABLED',
 });
 
+/**
+ * Services réellement déclarés dans la pile agents, override compris.
+ *
+ * Lue du fichier plutôt que codée en dur : une liste figée avait fini par
+ * annoncer `mailer`, qui ne vit que dans l'exemple d'override et n'existe donc
+ * pas tant que l'opérateur ne l'a pas décommenté. Proposer un service absent,
+ * c'est promettre un « no such service ».
+ *
+ * Sert au ROUTAGE : la pile agents est un projet Compose distinct de celui du
+ * workspace, donc `/start <nom>` doit partir vers `wiki-workspace agents`.
+ */
+export function agentServiceNames({ env = resolvedManagerEnv() } = {}) {
+  const { composeFiles } = resolveAgentsComposeContext({ env });
+  const names = new Set();
+  for (const file of composeFiles) {
+    try {
+      const parsed = YAML.parse(readFileSync(file, 'utf8')) ?? {};
+      for (const name of Object.keys(parsed.services ?? {})) names.add(name);
+    } catch { /* fichier illisible : il ne déclare rien d'adressable */ }
+  }
+  return [...names].sort();
+}
+
+/**
+ * Agents qu'un opérateur pilote un par un, proposés dans les complétions.
+ *
+ * Uniquement ceux placés derrière un drapeau de profil : ce sont les seuls
+ * qu'on active et désactive délibérément. `cme` et `documents` font partie du
+ * socle — on les démarre avec `agents`, les distinguer n'apporte rien et
+ * allonge une liste que l'opérateur doit lire à chaque fois.
+ */
+export function togglableAgentNames() {
+  return Object.keys(PROFILE_FLAGS).sort();
+}
+
 export function isEnabled(value) {
   return /^(?:1|true|yes|on)$/i.test(String(value ?? '').trim());
 }
 
+/**
+ * Pourquoi un service à profil est indisponible, et comment l'activer.
+ *
+ * Le message d'origine — « le service des connecteurs est indisponible ou
+ * désactivé » — ne disait ni lequel des deux, ni où regarder. Donna, à qui on
+ * demandait ensuite « comment l'activer », n'avait aucun fait à citer et
+ * inventait des fichiers (`cme.yaml`, un « manifeste des services actifs »)
+ * qui n'existent nulle part. Une réponse fausse et confiante coûte plus cher
+ * qu'un « je ne sais pas » : c'est le message qu'il faut rendre suffisant,
+ * pas le modèle qu'il faut espérer plus prudent.
+ *
+ * @returns {{ enabled: boolean, flag: string, envFile: string, message: string }}
+ */
+export function profileServiceStatus(profile, { env = resolvedManagerEnv() } = {}) {
+  const flag = PROFILE_FLAGS[profile];
+  const envFile = managerEnvFile();
+  if (!flag) {
+    return {
+      enabled: false,
+      flag: null,
+      envFile,
+      message: `There is no "${profile}" service in this deployment.`,
+    };
+  }
+  const enabled = isEnabled(env[flag]);
+  if (enabled) {
+    return {
+      enabled: true,
+      flag,
+      envFile,
+      message: `The ${profile} service is enabled (${flag}) but not reachable — its container is probably not running. Start it with \`/start agents\`.`,
+    };
+  }
+  const current = String(env[flag] ?? '').trim();
+  return {
+    enabled: false,
+    flag,
+    envFile,
+    message: [
+      `The ${profile} service is disabled: ${flag} is ${current === '' ? 'not set' : `"${current}"`} in ${envFile}.`,
+      'To enable it:',
+      `  1. set ${flag}=true in ${envFile}`,
+      '  2. run `/start agents` (or `wiki-workspace agents up`) to start its container',
+      `  3. run \`/connector list\` to check it answers`,
+      `The ${profile} service runs behind a Compose profile, so while ${flag} is off its container does not exist at all — it will not appear in \`docker compose ps\`.`,
+    ].join('\n'),
+  };
+}
+
 /**
  * The manager `.env` wins over the ambient process environment.
  *