@dotdrelle/wiki-manager 0.15.34 → 0.15.35

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/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.35",
   "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/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,
@@ -1058,6 +1060,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 +1102,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 +1207,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 +1221,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 () => {

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.
  *

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.34",
-  "commit": "8b6b1aa"
+  "version": "0.15.35",
+  "commit": "9bca2fd"
 }

package/src/core/compose.js

@@ -19,11 +19,17 @@ const execFileAsync = promisify(execFile);
 export const COMPOSE_SERVICES = ['serve', 'mcp-http', 'production-mcp'];
 const SERVICE_DESCRIPTION_LABEL = 'wiki-manager.description';
 
+// Deux alias seulement, pour les deux services qu'un opérateur pilote vraiment
+// à part. `mcp-http` n'en a plus : il fait partie du socle démarré par `all` et
+// `services`, et son alias `mcp` ajoutait une ligne à lire pour un service que
+// personne ne démarre seul. Il reste adressable sous son nom Compose.
+//
+// Pas d'alias `wiki` non plus : c'est déjà le nom du service Compose one-shot
+// derrière `/wiki run`. En faire un alias de `mcp-http` le masquait, et
+// `/start wiki` démarrait silencieusement un autre service que celui nommé.
 const DEFAULT_SERVICE_ALIASES = {
   all: COMPOSE_SERVICES,
   ui: ['serve'],
-  wiki: ['mcp-http'],
-  mcp: ['mcp-http'],
   production: ['production-mcp'],
 };
 
@@ -92,6 +98,22 @@ export function serviceNames() {
   return [...new Set([...COMPOSE_SERVICES, ...Object.keys(serviceAliases())])].sort();
 }
 
+/**
+ * Noms proposés à la complétion de `/start`, `/stop` et `/logs`.
+ *
+ * La liste complète mélangeait les alias et les services Compose qu'ils
+ * désignent — `mcp` et `mcp-http`, `ui` et `serve`, `production` et
+ * `production-mcp` — et affichait `all` deux fois, une fois comme mot-clé du
+ * shell et une fois comme alias Compose. Dix entrées pour cinq actions
+ * réelles. On ne propose donc que le vocabulaire destiné à l'opérateur ; les
+ * noms Compose bruts restent acceptés si on les tape.
+ */
+export function serviceChoices() {
+  const aliases = Object.keys(serviceAliases());
+  // `all` est ajouté par l'appelant, en tête : c'est le choix par défaut.
+  return aliases.filter((name) => name !== 'all').sort();
+}
+
 export function serviceDescription(name) {
   return serviceDescriptions()[name] ?? null;
 }

package/src/core/dockerCompose.test.js

@@ -19,11 +19,29 @@ test('workspace compose does not start a per-workspace agent runtime', async ()
   );
 });
 
+test('shipped compose files never carry a build context', async () => {
+  // Ces deux fichiers partent dans le paquet npm, où les dépôts frères
+  // (`../agent-external/…`) n'existent pas : un `build:` y rend toute commande
+  // Compose irrésolvable chez l'utilisateur. Les images sont construites et
+  // publiées par build-and-push.sh, jamais par le manager.
+  for (const file of ['../../docker-compose.yml', '../../agents.docker-compose.yml']) {
+    const compose = YAML.parse(await readFile(new URL(file, import.meta.url), 'utf8'));
+    for (const [name, service] of Object.entries(compose.services ?? {})) {
+      assert.equal(service.build, undefined, `${file} ${name}: shipped files must reference an image, never build it`);
+      assert.ok(service.image, `${file} ${name}: must declare an image`);
+    }
+  }
+});
+
 test('no compose service relies on a bare environment passthrough', async () => {
   // `- VAR` makes Compose print `The "VAR" variable is not set. Defaulting to a
   // blank string.` for every key the operator left as a commented placeholder —
   // CONNECTORS_MCP_PORT once connectors were enabled. That warning reached the
   // ShellUI looking like a failure. Every entry must carry its own default.
+  //
+  // Une valeur vide est ici sans danger : l'application OAuth embarquée dans
+  // l'image du connecteur est lue depuis un fichier, plus depuis un ENV que la
+  // chaîne vide écraserait.
   for (const file of ['../../docker-compose.yml', '../../agents.docker-compose.yml']) {
     const compose = YAML.parse(await readFile(new URL(file, import.meta.url), 'utf8'));
     for (const [name, service] of Object.entries(compose.services ?? {})) {

package/src/core/googleGrants.js

@@ -0,0 +1,38 @@
+/**
+ * Droits Gmail demandés à Google, et ce qu'ils ouvrent réellement.
+ *
+ * Les identifiants (`read`, `send`, `modify`) sont ceux de Google — `modify`
+ * vient du scope `gmail.modify` — et ceux de `GOOGLE_GRANTS` dans
+ * agent-connectors. Leur inventer un synonyme côté manager créerait une
+ * troisième orthographe à tenir à jour, exactement le travers qui avait donné
+ * une seconde paire de variables OAuth préfixées. On décrit, on ne renomme pas.
+ *
+ * Cette table est la source unique : la valeur par défaut de
+ * `/connector auth`, l'aide de la complétion et le rendu de `/connector list`
+ * en découlent tous, donc ils ne peuvent pas diverger.
+ */
+export const GOOGLE_GRANT_LABELS = Object.freeze({
+  read: 'read messages and collect them into the workspace',
+  send: 'send email from your account (subject to the recipient allow-list)',
+  modify: 'mark read/unread, archive, label, star, trash (never permanent deletion)',
+});
+
+export const GOOGLE_GRANTS = Object.freeze(Object.keys(GOOGLE_GRANT_LABELS));
+
+/**
+ * Droits demandés quand l'opérateur n'en nomme aucun.
+ *
+ * Tout ce que l'agent sait faire. Un défaut plus étroit promet des actions que
+ * l'autorisation ne couvre pas : `/connector auth google` ne demandait que
+ * `read`, alors que l'agent expose l'envoi et la gestion de boîte — Donna
+ * proposait « marquer comme lu », et l'action échouait après coup. Comme
+ * l'autorisation Google est incrémentale, un droit ajouté plus tard coûte un
+ * aller-retour de consentement supplémentaire, pas moins d'accès.
+ */
+export function defaultGoogleGrants() {
+  return [...GOOGLE_GRANTS];
+}
+
+export function describeGoogleGrant(grant) {
+  return GOOGLE_GRANT_LABELS[grant] ?? null;
+}

package/src/core/googleGrants.test.js

@@ -0,0 +1,59 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { GOOGLE_GRANTS, GOOGLE_GRANT_LABELS, defaultGoogleGrants } from './googleGrants.js';
+
+const connectorsSrc = (file) =>
+  readFileSync(fileURLToPath(new URL(`../../../agent-external/agent-connectors/src/${file}`, import.meta.url)), 'utf8');
+
+test('the grant names mirror the agent, spelling included', () => {
+  // `modify` est le nom de Google (scope gmail.modify) et celui de l'agent.
+  // Un synonyme côté manager créerait une troisième orthographe à tenir à jour
+  // — le travers qui avait déjà donné une seconde paire de variables OAuth.
+  const tokens = connectorsSrc('googleTokens.ts');
+  const declared = tokens.match(/GOOGLE_GRANTS: readonly GoogleGrant\[\] = \[([^\]]+)\]/)?.[1] ?? '';
+  const agentGrants = [...declared.matchAll(/'([a-z]+)'/g)].map(([, grant]) => grant);
+
+  assert.deepEqual([...GOOGLE_GRANTS].sort(), agentGrants.sort());
+});
+
+test('every grant is described in plain words, never left as a bare token', () => {
+  for (const grant of GOOGLE_GRANTS) {
+    const label = GOOGLE_GRANT_LABELS[grant];
+    assert.ok(label && label.length > 10, `${grant} needs a human description`);
+    assert.notEqual(label, grant);
+  }
+});
+
+test('the default asks for everything the agent can actually do', () => {
+  // Un défaut plus étroit promet des actions que l'autorisation ne couvre pas :
+  // `/connector auth google` ne demandait que `read`, et l'envoi comme le
+  // marquage échouaient après coup, en ressemblant à des fonctions absentes.
+  assert.deepEqual(defaultGoogleGrants().sort(), [...GOOGLE_GRANTS].sort());
+
+  // Chaque droit du défaut doit ouvrir quelque chose de réellement exposé.
+  const server = connectorsSrc('server.ts');
+  const contract = connectorsSrc('contract.ts');
+  assert.match(contract, /CAPABILITY_ID = 'external-source\.collect'/, 'read feeds the collect capability');
+  assert.match(contract, /SEND_CAPABILITY_ID = 'communication\.send-email'/, 'send has a capability');
+  assert.match(server, /'connectors_gmail_modify'/, 'modify has a tool');
+});
+
+test('the default grants are not mutated by the caller', () => {
+  const first = defaultGoogleGrants();
+  first.push('bogus');
+  assert.deepEqual(defaultGoogleGrants().sort(), [...GOOGLE_GRANTS].sort());
+});
+
+test('the destructive Gmail tool needs approval and stays out of chat mode', () => {
+  const script = readFileSync(fileURLToPath(new URL('../../wiki-workspace', import.meta.url)), 'utf8');
+  const block = script.slice(script.indexOf('config.mcpServers.connectors ??='), script.indexOf('delete connectorAccess.allowActions'));
+  const approval = block.slice(block.indexOf('requireApproval'), block.indexOf('chatAccess'));
+  const chatAllow = block.slice(block.indexOf('connectorAccess.allow ='));
+
+  assert.match(approval, /connectors_gmail_modify/, 'a destructive tool must be approval-gated');
+  // /chat est en lecture seule : une mutation n'y a pas sa place, elle passe
+  // par /agent où l'allow-list ne s'applique pas.
+  assert.ok(!chatAllow.includes('connectors_gmail_modify'), 'chat mode must stay read-only');
+});