@dotdrelle/wiki-manager 0.15.28 → 0.15.32

package/src/commands/slash.js

@@ -30,6 +30,8 @@ import {
   summarizeWikircConfig,
 } from '../core/wikirc.js';
 import { applySessionWikircProfile } from '../core/sessionConfig.js';
+import { loadManagerEnv } from '../core/env.js';
+import { resolveSchedulerConcurrency } from '../orchestrator/scheduler.js';
 import {
   deleteWorkspaceAndFiles,
   finalizeCreatedWorkspace,
@@ -83,6 +85,18 @@ function twoColumns(left, right) {
   return out.join('\n');
 }
 
+export function compactBaseUrl(value) {
+  const raw = String(value ?? '').trim();
+  if (!raw) return '-';
+  try {
+    const parsed = new URL(raw);
+    const label = parsed.host || parsed.hostname;
+    return label ? `[${label}](${raw})` : raw;
+  } catch {
+    return raw.replace(/^https?:\/\//i, '').replace(/\/+$/, '') || '-';
+  }
+}
+
 function commandLabel(value) {
   return `${styles.bold}${styles.cyan}${value}${styles.reset}`;
 }
@@ -222,20 +236,68 @@ function statLine(label, stat) {
   return `${label}: ${stat.count} (${formatBytes(stat.totalBytes)})`;
 }
 
-function workspaceStatsColumns(stats) {
+function positiveConcurrency(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.max(1, Math.floor(parsed)) : fallback;
+}
+
+function discoveredAgentLimits(session, agentType) {
+  const agents = session?.agentRegistry?.snapshot?.() ?? session?.agentRegistrySnapshot ?? [];
+  const agent = agents.find((entry) =>
+    String(entry?.description?.agentType ?? '').toLowerCase() === agentType
+    || String(entry?.serverName ?? '').toLowerCase().includes(agentType));
+  return agent?.description?.limits ?? {};
+}
+
+export function agentConcurrencySections(session, env = process.env) {
+  const managerCeiling = positiveConcurrency(env.WIKI_MANAGER_CAPABILITY_CONCURRENCY, null);
+  const productionLimits = discoveredAgentLimits(session, 'production');
+  const productionRecommended = positiveConcurrency(
+    productionLimits.recommendedConcurrency ?? env.PRODUCTION_RECOMMENDED_CONCURRENCY,
+    4,
+  );
+  const productionMaximum = positiveConcurrency(
+    productionLimits.maxConcurrency ?? env.PRODUCTION_MAX_CONCURRENCY,
+    8,
+  );
+  const productionEffective = Math.min(
+    productionRecommended,
+    productionMaximum,
+    managerCeiling ?? Number.POSITIVE_INFINITY,
+  );
+
+  const connectorLimits = discoveredAgentLimits(session, 'connectors');
+  const collectionRecommended = positiveConcurrency(
+    connectorLimits.recommendedConcurrency ?? env.CONNECTORS_RECOMMENDED_CONCURRENCY,
+    2,
+  );
+  const collectionMaximum = positiveConcurrency(
+    connectorLimits.maxConcurrency ?? env.CONNECTORS_MAX_CONCURRENCY,
+    4,
+  );
+  const collectionEffective = Math.min(
+    collectionRecommended,
+    collectionMaximum,
+    managerCeiling ?? Number.POSITIVE_INFINITY,
+  );
+
+  return {
+    production: sectionBlock('Parallelism & throughput', [
+      `effective: ${productionEffective}`,
+      `recommended: ${productionRecommended}`,
+      `maximum: ${productionMaximum}`,
+      `scheduler workers: ${resolveSchedulerConcurrency(env.WIKI_MANAGER_SCHEDULER_CONCURRENCY)}`,
+    ]),
+    collection: sectionBlock('Collection concurrency', [
+      `effective: ${collectionEffective}`,
+      `recommended: ${collectionRecommended}`,
+      `maximum: ${collectionMaximum}`,
+    ]),
+  };
+}
+
+function workspaceStatsColumns(stats, session) {
   if (!stats) return { left: 'No workspace loaded.', right: '' };
-  const hints = [];
-  if (stats.untracked.count > 0) {
-    hints.push(`${stats.untracked.count} raw/untracked document(s) are waiting for ingest.`);
-  }
-  if (!stats.index.exists) {
-    hints.push('wiki/index.md is missing.');
-  } else if (stats.index.links === 0) {
-    hints.push('wiki/index.md exists but has no markdown/wiki links.');
-  }
-  if (stats.wiki.count === 0) {
-    hints.push('The wiki has no markdown pages yet.');
-  }
 
   const wikiLatest = formatDate(Math.max(
       stats.wiki.latest?.mtimeMs ?? 0,
@@ -266,14 +328,11 @@ function workspaceStatsColumns(stats) {
     statLine('templates', stats.templates),
     statLine('deliverables', stats.deliverables),
   ]);
-  const internalColumn = sectionBlock('Internal', [
-    `logs: ${stats.logs.count} (${formatBytes(stats.logs.totalBytes)})`,
-  ]);
-  const hintsColumn = sectionBlock('Hints', hints.length > 0 ? hints : ['No immediate content action detected.']);
+  const concurrency = agentConcurrencySections(session);
 
   return {
     left: [wikiColumn, deliveryColumn].join('\n\n'),
-    right: [rawColumn, internalColumn, hintsColumn].join('\n\n'),
+    right: [rawColumn, concurrency.production, concurrency.collection].join('\n\n'),
   };
 }
 
@@ -353,6 +412,44 @@ function mcpEndpointsText(mcpStatus) {
     .join('\n');
 }
 
+function mcpPort(endpoint) {
+  const value = String(endpoint?.url ?? endpoint?.configuredUrl ?? '');
+  try {
+    const parsed = new URL(value);
+    if (parsed.port) return parsed.port;
+    if (parsed.protocol === 'https:') return '443';
+    if (parsed.protocol === 'http:') return '80';
+  } catch {
+    // Placeholders in configured URLs are not valid URL syntax; use the
+    // resolved trailing numeric port when one is present.
+  }
+  return value.match(/:(\d+)(?:\/|$)/)?.[1] ?? '-';
+}
+
+export function compactMcpStatus(mcpStatus) {
+  const entries = Object.entries(mcpStatus ?? {});
+  if (entries.length === 0) return '○ none';
+  return entries
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([name, endpoint]) => {
+      // `configured` covers two very different situations: an endpoint we
+      // never probed (service stopped) and one whose probe failed. Reporting
+      // both as "configured" is what makes a live agent look unconfigured —
+      // surface the failure as its own state, with the cause one command away
+      // (`/mcp status` prints the full toolsError).
+      if (endpoint.status !== 'connected' && endpoint.toolError) {
+        return `✕ ${name}  :${mcpPort(endpoint)}  unreachable (/mcp status)`;
+      }
+      const marker = endpoint.status === 'connected'
+        ? '●'
+        : endpoint.status === 'configured'
+          ? '◐'
+          : '○';
+      return `${marker} ${name}  :${mcpPort(endpoint)}  ${endpoint.status ?? 'unknown'}`;
+    })
+    .join('\n');
+}
+
 function skillsText(session) {
   const skills = listSkills(session);
   if (skills.length === 0) return 'No skills discovered.';
@@ -511,8 +608,7 @@ export async function refreshMcpRuntimeStatus(session) {
 async function statusText(session) {
   const states = await refreshMcpRuntimeStatus(session);
   const workspaceStats = collectWorkspaceStats(session);
-  const workspaceColumn = sectionBlock('Workspace', [
-    `workspace: ${session.workspace ?? '-'}`,
+  const workspaceColumn = sectionBlock(`Workspace · ${session.workspace ?? '-'}`, [
     `path: ${compactPath(session.workspacePath ?? '-')}`,
     `env: ${compactPath(session.workspaceEnvFile ?? '-')}`,
   ]);
@@ -522,22 +618,20 @@ async function statusText(session) {
     `llm: ${session.llm ? 'configured' : 'missing'}`,
     `provider: ${session.wikircConfig?.llm?.provider ?? '-'}`,
     `model: ${session.wikircConfig?.llm?.model ?? '-'}`,
-    `baseUrl: ${session.wikircConfig?.llm?.baseUrl ?? '-'}`,
+    `baseUrl: ${compactBaseUrl(session.wikircConfig?.llm?.baseUrl)}`,
   ]);
   const runtimeColumn = sectionBlock('Runtime', (states ? serviceStatesText(states) : 'Docker runtime not available or no workspace loaded.').split('\n'));
-  const mcpColumn = sectionBlock('MCP', formatMcpStatus(session.mcp).split('\n'));
-  const mcpToolsColumn = sectionBlock('MCP tool summary', formatMcpToolSummary(session.mcp).split('\n'));
-  const stats = workspaceStatsColumns(workspaceStats);
+  const mcpColumn = sectionBlock('MCP', compactMcpStatus(session.mcp).split('\n'));
+  const stats = workspaceStatsColumns(workspaceStats, session);
 
   const leftColumn = [workspaceColumn, stats.left, runtimeColumn, mcpColumn].filter(Boolean).join('\n\n');
-  const rightColumn = [configColumn, stats.right, mcpToolsColumn].filter(Boolean).join('\n\n');
-
-  // Leading/trailing padding row on *both* columns so the boxed pair doesn't
-  // butt directly against the pane border when the view is scrolled to show
-  // the tail. A single space on each side (not '') keeps the row tab-joined,
-  // so both the left and right box render — an empty string on either side
-  // of the tab makes twoColumns drop the pairing and only the left box shows.
-  const pad = ' \t ';
+  const rightColumn = [configColumn, stats.right].filter(Boolean).join('\n\n');
+
+  // Leading/trailing blank row so the boxed pair doesn't butt directly against
+  // the pane border when the view is scrolled to show the tail. It is padding,
+  // not data: LeftPane renders a row that is blank on both sides as a plain
+  // spacer, so no empty bordered box is drawn past the last real line.
+  const pad = ' ';
   return [pad, twoColumns(leftColumn, rightColumn), pad].join('\n');
 }
 
@@ -598,6 +692,7 @@ Usage:
 Options:
   -v, --version        Print version
   -h, --help           Print help
+  --refresh            Stop runtime and project containers; remove project images
   --cacert <path>      Trust a local CA; Docker must be able to read this host path
   --once <prompt>      Run one agent turn and exit
   --headless           Run a workspace task non-interactively
@@ -616,7 +711,7 @@ ${helpPair('/workspace list', 'Workspaces', '/new <n> [path]', 'New workspace')}
 ${helpPair('/use <workspace>', 'Use workspace', '/status', 'Session status')}
 ${helpPair('/config list', 'Config profiles', '/config use <n>', 'Use config')}
 ${helpPair('/config edit <n>', 'Edit config', '/workspace delete <n>', 'Delete workspace')}
-${helpPair('/services', 'Services', '/start [all|service|agents]', 'Start service(s)')}
+${helpPair('/services', 'Services', '/start [all|agents|services]', 'all = services + agents')}
 ${helpPair('/stop [all|service|agents]', 'Stop service(s)', '/logs <service>', 'Service logs')}
 ${helpPair('/skills', 'List skills', '/skills show <n>', 'Show skill')}
 ${helpPair('/skills run <n>', 'Run skill guide', '/skills edit <n>', 'Edit skill')}
@@ -656,11 +751,12 @@ export function printHelp(packageJson) {
   console.log(helpText(packageJson));
 }
 
-function rawCommandAgentPrompt(command, output) {
+export function rawCommandAgentPrompt(command, output) {
   return [
     `L'utilisateur a lancé la commande shell ${command}.`,
-    'Voici la sortie brute collectée par la commande déterministe. Ne relance pas la commande et ne modifie pas les données.',
+    'Voici la sortie brute collectée par la commande déterministe. Ne relance pas la commande, ne modifie pas les données et n’appelle aucun outil.',
     'Réponds à l’utilisateur à partir de ces faits, en appliquant le profil workspace et les préférences de présentation déjà chargés dans ton prompt système.',
+    'Ne reproduis pas les détails techniques, identifiants internes, chemins, noms de conteneurs ou sorties brutes. Donne seulement le résultat utile en langage naturel.',
     '',
     'Sortie brute:',
     '```text',
@@ -731,6 +827,10 @@ export function localizedOperationFailure({ operation, target, error }) {
   return {
     output: facts,
     rawOutput: true,
+    // The status only lived inside the serialized facts, so a caller chaining
+    // two operations (/start all = agents then services) had to re-parse JSON
+    // to know whether to continue. Surface it as a plain flag.
+    failed: true,
     agentTrigger: [
       "Formule l'échec structuré suivant dans la langue et le ton demandés par le profil du workspace.",
       "Réponds en une ou deux phrases humaines: ce qui a échoué, et l'action concrète que la personne peut faire.",
@@ -779,6 +879,19 @@ export async function handleSlashCommand(line, context) {
     try {
       step(`Agents: ${verb}ing external agents…`);
       const missingImages = await collectMissingImages(step, fn);
+      if (verb === 'start') {
+        // `wiki-workspace agents up` generates the agent tokens into the
+        // manager .env and adds the profiled entries to mcp.endpoints.json.
+        // Both were read at boot, so without re-reading them the endpoint the
+        // script just wrote resolves with an empty ${..._AUTH_TOKEN} and the
+        // freshly started agent stays "credential not set" until a restart.
+        step('Agents: reloading manager environment and MCP endpoints…');
+        // The script may have replaced a blank/generated token that was
+        // already loaded at boot. A non-overriding dotenv reload would keep
+        // the stale process value and defeat the refresh.
+        loadManagerEnv({ override: true });
+        await refreshMcpRuntimeStatus(context.session);
+      }
       return localizedOperationResult({
         operation: verb,
         target: 'agents',
@@ -945,21 +1058,37 @@ 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');
+      // "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
+      // workspace-only behaviour.
+      const startsAgents = service === 'all';
+      const target = service === 'services' ? undefined : service;
       try {
-        step(`Services: starting ${service ?? 'workspace services'}…`);
-        const missingImages = await collectMissingImages(step, (opts) => startService(context.session, service, opts));
+        if (startsAgents) {
+          // Validate the workspace half before mutating the global agents
+          // stack. Otherwise `/start all` with no active workspace starts the
+          // agents successfully and only then fails, leaving a partial start.
+          if (!context.session.workspace || !context.session.workspacePath || !context.session.workspaceEnv?.WORKSPACE_NAME) {
+            throw new Error('No workspace loaded. Use /use <workspace>.');
+          }
+          const agentsResult = await runAgentCommand(startAgents, 'start');
+          if (agentsResult?.failed) return agentsResult;
+        }
+        step(`Services: starting ${target ?? 'workspace services'}…`);
+        const missingImages = await collectMissingImages(step, (opts) => startService(context.session, target, opts));
         step('Services: refreshing MCP runtime…');
         await refreshMcpRuntimeStatus(context.session);
         return localizedOperationResult({
           operation: 'start',
-          target: service || 'workspace-services',
+          target: startsAgents ? 'all-services-and-agents' : (target || 'workspace-services'),
           componentAction: componentInstallAction(missingImages),
           images: missingImages,
         });
       } catch (err) {
         step(formatActivityError('services', 'start', err));
         step(`Services: docker output — ${rawFailureText(err)}`);
-        return localizedOperationFailure({ operation: 'start', target: service || 'workspace-services', error: err });
+        return localizedOperationFailure({ operation: 'start', target: target || 'workspace-services', error: err });
       }
     }
     case 'stop': {

package/src/commands/slash.test.js

@@ -4,7 +4,7 @@ import { mkdtemp } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
-import { handleSlashCommand, localizedOperationResult } from './slash.js';
+import { agentConcurrencySections, compactBaseUrl, compactMcpStatus, handleSlashCommand, localizedOperationResult } from './slash.js';
 import { completionContext } from '../shell/repl.js';
 
 test('deterministic operation results ask Donna to localize compact facts without leaking commands', () => {
@@ -15,6 +15,68 @@ test('deterministic operation results ask Donna to localize compact facts withou
   assert.doesNotMatch(result.agentTrigger, /\/start|Docker|compose/);
 });
 
+test('/status MCP overview contains only connector name, port and status', () => {
+  const output = compactMcpStatus({
+    connectors: {
+      url: 'http://localhost:3338/mcp/',
+      status: 'connected',
+      tools: Array.from({ length: 20 }, (_, index) => ({ name: `long_tool_${index}` })),
+      toolError: 'a very long technical error that must stay out of the overview',
+    },
+    cme: {
+      configuredUrl: 'http://host.docker.internal:3336/mcp/',
+      status: 'configured',
+      detail: 'some long runtime detail',
+    },
+  });
+
+  assert.equal(output, '◐ cme  :3336  configured\n● connectors  :3338  connected');
+  assert.doesNotMatch(output, /tools|error|detail|http/i);
+});
+
+test('/status base URL displays only its domain while retaining the full link', () => {
+  assert.equal(
+    compactBaseUrl('https://albert.api.etalab.gouv.fr/v1'),
+    '[albert.api.etalab.gouv.fr](https://albert.api.etalab.gouv.fr/v1)',
+  );
+  assert.equal(compactBaseUrl('http://localhost:11434/v1'), '[localhost:11434](http://localhost:11434/v1)');
+  assert.equal(compactBaseUrl(undefined), '-');
+});
+
+test('/status replaces Internal and Hints with effective agent concurrency', () => {
+  const sections = agentConcurrencySections({
+    agentRegistrySnapshot: [
+      {
+        serverName: 'production',
+        description: {
+          agentType: 'production',
+          limits: { recommendedConcurrency: 6, maxConcurrency: 10 },
+        },
+      },
+      {
+        serverName: 'connectors',
+        description: {
+          agentType: 'connectors',
+          limits: { recommendedConcurrency: 3, maxConcurrency: 5 },
+        },
+      },
+    ],
+  }, {
+    WIKI_MANAGER_CAPABILITY_CONCURRENCY: '4',
+    WIKI_MANAGER_SCHEDULER_CONCURRENCY: '7',
+  });
+
+  assert.match(sections.production, /Parallelism & throughput/);
+  assert.match(sections.production, /effective: 4/);
+  assert.match(sections.production, /recommended: 6/);
+  assert.match(sections.production, /maximum: 10/);
+  assert.doesNotMatch(sections.production, /manager ceiling/);
+  assert.match(sections.production, /scheduler workers: 7/);
+  assert.match(sections.collection, /Collection concurrency/);
+  assert.match(sections.collection, /effective: 3/);
+  assert.doesNotMatch(`${sections.production}\n${sections.collection}`, /Internal|Hints/);
+});
+
 test('start result tells Donna when missing container components were installed', () => {
   const result = localizedOperationResult({
     operation: 'start',
@@ -32,6 +94,43 @@ test('start result tells Donna when missing container components were installed'
   assert.match(result.agentTrigger, /downloaded-and-installed-missing-components/);
 });
 
+test('/start all covers the agents as well as the workspace services', async () => {
+  const { readFile } = await import('node:fs/promises');
+  const source = await readFile(new URL('./slash.js', import.meta.url), 'utf8');
+  const start = source.slice(source.indexOf("case 'start': {"), source.indexOf("case 'stop': {"));
+
+  // "all" used to start the workspace services only, which left every external
+  // agent down while the wording promised the opposite.
+  assert.match(start, /const startsAgents = service === 'all';/);
+  assert.match(start, /const target = service === 'services' \? undefined : service;/);
+  assert.match(start, /await runAgentCommand\(startAgents, 'start'\)/);
+  assert.match(start, /if \(agentsResult\?\.failed\) return agentsResult;/);
+  assert.match(start, /if \(!context\.session\.workspace \|\| !context\.session\.workspacePath/);
+  assert.match(start, /service === 'agents' \|\| service === 'agent'/);
+});
+
+test('a started agent stack reloads the env and the MCP endpoints the script rewrote', async () => {
+  const { readFile } = await import('node:fs/promises');
+  const source = await readFile(new URL('./slash.js', import.meta.url), 'utf8');
+  const runAgent = source.slice(source.indexOf('const runAgentCommand ='), source.indexOf('switch (command)'));
+
+  assert.match(runAgent, /if \(verb === 'start'\)/);
+  assert.match(runAgent, /loadManagerEnv\(\{ override: true \}\);/);
+  assert.match(runAgent, /await refreshMcpRuntimeStatus\(context\.session\)/);
+});
+
+test('/start completes to the three documented targets', async () => {
+  const { completionDescription } = await import('../shell/repl.js');
+  const { matches } = completionContext('/start ', {});
+
+  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/);
+});
+
 test('/workspace delete removes files and clears current session context after confirmation', async () => {
   const root = await mkdtemp(join(tmpdir(), 'wiki-manager-delete-workspace-'));
   const registryRoot = join(root, 'registry');

package/src/core/agentsCompose.js

@@ -0,0 +1,79 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { managerComposeOverrideFile, managerEnvFile, readEnvFile } from './env.js';
+import { managerRoot } from './workspaces.js';
+
+export const AGENTS_COMPOSE_PROJECT = 'wiki-agents';
+export const AGENTS_COMPOSE_FILE = 'agents.docker-compose.yml';
+export const AGENTS_COMPOSE_OVERRIDE = 'agents.docker-compose.override.yml';
+
+// Services behind a compose profile, and the manager flag that activates each.
+// A profiled service is invisible to every compose command — `ps` included —
+// unless its profile is active, which is why an inactive profile used to look
+// exactly like "the flag was ignored".
+export const PROFILE_FLAGS = Object.freeze({
+  connectors: 'CONNECTORS_ENABLED',
+});
+
+export function isEnabled(value) {
+  return /^(?:1|true|yes|on)$/i.test(String(value ?? '').trim());
+}
+
+/**
+ * The manager `.env` wins over the ambient process environment.
+ *
+ * Compose normally gives an already-exported process variable precedence over
+ * `--env-file`. The manager deliberately defines the opposite policy for its
+ * owned configuration, then passes this resolved environment explicitly to
+ * `wiki-workspace`, so stale values loaded at boot cannot shadow a later .env
+ * update.
+ */
+export function resolvedManagerEnv() {
+  let fileEnv = {};
+  try {
+    fileEnv = readEnvFile(managerEnvFile());
+  } catch {
+    // No manager .env yet: valid during first-run setup.
+  }
+  return { ...process.env, ...fileEnv };
+}
+
+/**
+ * Single source of truth for how the agents stack is addressed: the compose
+ * files, the user-owned override, the active profiles and the project name.
+ * `checkAgents`, the image detection and the post-start verification all go
+ * through this, so they can never observe a different set of services than the
+ * one `wiki-workspace agents up` actually started.
+ */
+export function resolveAgentsComposeContext({ env = resolvedManagerEnv() } = {}) {
+  const composeFile = join(managerRoot(), AGENTS_COMPOSE_FILE);
+  const envFile = managerEnvFile();
+  const overrideFile = managerComposeOverrideFile(AGENTS_COMPOSE_OVERRIDE);
+  const profiles = Object.entries(PROFILE_FLAGS)
+    .filter(([, flag]) => isEnabled(env[flag]))
+    .map(([profile]) => profile)
+    .sort();
+
+  const composeFiles = [composeFile, ...(existsSync(overrideFile) ? [overrideFile] : [])];
+  const args = ['compose', '--project-directory', managerRoot()];
+  if (existsSync(envFile)) args.push('--env-file', envFile);
+  for (const file of composeFiles) args.push('-f', file);
+  for (const profile of profiles) args.push('--profile', profile);
+  args.push('-p', AGENTS_COMPOSE_PROJECT);
+
+  return {
+    args,
+    profiles,
+    env,
+    composeFile,
+    composeFiles,
+    envFile,
+    overrideFile,
+    exists: existsSync(composeFile),
+    // Services the operator asked for that a `ps` MUST therefore report as
+    // running — an enabled profile whose container is absent is a failure, not
+    // an opt-out.
+    expectedProfileServices: profiles,
+  };
+}

package/src/core/agentsCompose.test.js

@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import test from 'node:test';
+
+import { loadManagerEnv } from './env.js';
+import { isEnabled, resolveAgentsComposeContext, resolvedManagerEnv } from './agentsCompose.js';
+
+async function withManagerState(files, fn) {
+  const root = await mkdtemp(join(tmpdir(), 'wiki-manager-agents-compose-'));
+  mkdirSync(root, { recursive: true });
+  for (const [name, content] of Object.entries(files)) {
+    const file = join(root, name);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, content, 'utf8');
+  }
+  const previousEnvFile = process.env.WIKI_MANAGER_ENV_FILE;
+  const previousFlag = process.env.CONNECTORS_ENABLED;
+  process.env.WIKI_MANAGER_ENV_FILE = join(root, '.env');
+  try {
+    await fn({ root });
+  } finally {
+    if (previousEnvFile === undefined) delete process.env.WIKI_MANAGER_ENV_FILE;
+    else process.env.WIKI_MANAGER_ENV_FILE = previousEnvFile;
+    if (previousFlag === undefined) delete process.env.CONNECTORS_ENABLED;
+    else process.env.CONNECTORS_ENABLED = previousFlag;
+  }
+}
+
+test('isEnabled accepts every documented truthy spelling', () => {
+  for (const value of ['1', 'true', 'TRUE', 'yes', 'on', ' true ']) {
+    assert.equal(isEnabled(value), true, value);
+  }
+  for (const value of ['0', 'false', 'no', 'off', '', undefined, null, 'maybe']) {
+    assert.equal(isEnabled(value), false, String(value));
+  }
+});
+
+test('the connectors profile activates from the manager .env alone', async () => {
+  await withManagerState({ '.env': 'CONNECTORS_ENABLED=true\n' }, () => {
+    delete process.env.CONNECTORS_ENABLED;
+    assert.deepEqual(resolveAgentsComposeContext().profiles, ['connectors']);
+  });
+});
+
+test('the connectors profile activates from process.env when the .env is silent', async () => {
+  await withManagerState({ '.env': 'WORKSPACES_ROOT=/tmp/ws\n' }, () => {
+    process.env.CONNECTORS_ENABLED = 'true';
+    assert.deepEqual(resolveAgentsComposeContext().profiles, ['connectors']);
+  });
+});
+
+test('the manager .env wins over the ambient process environment', async () => {
+  // The manager enforces this policy before invoking Compose; otherwise an
+  // exported empty/stale value would beat --env-file.
+  await withManagerState({ '.env': 'CONNECTORS_ENABLED=false\n' }, () => {
+    process.env.CONNECTORS_ENABLED = 'true';
+    assert.equal(resolvedManagerEnv().CONNECTORS_ENABLED, 'false');
+    assert.deepEqual(resolveAgentsComposeContext().profiles, []);
+  });
+});
+
+test('an explicit manager env reload replaces values generated after boot', async () => {
+  await withManagerState({ '.env': 'CONNECTORS_MCP_AUTH_TOKEN=fresh-token\n' }, () => {
+    process.env.CONNECTORS_MCP_AUTH_TOKEN = '';
+    loadManagerEnv();
+    assert.equal(process.env.CONNECTORS_MCP_AUTH_TOKEN, '');
+    loadManagerEnv({ override: true });
+    assert.equal(process.env.CONNECTORS_MCP_AUTH_TOKEN, 'fresh-token');
+    delete process.env.CONNECTORS_MCP_AUTH_TOKEN;
+  });
+});
+
+test('the user-owned override is passed whenever it exists', async () => {
+  await withManagerState({
+    '.env': 'CONNECTORS_ENABLED=true\n',
+    '.wiki/compose/agents.docker-compose.override.yml': 'services: {}\n',
+  }, ({ root }) => {
+    const { args, composeFiles, overrideFile } = resolveAgentsComposeContext();
+    assert.equal(overrideFile, join(root, '.wiki', 'compose', 'agents.docker-compose.override.yml'));
+    assert.equal(composeFiles.length, 2);
+    assert.ok(args.includes(overrideFile));
+    assert.deepEqual(args.slice(args.indexOf('--profile'), args.indexOf('--profile') + 2), ['--profile', 'connectors']);
+    assert.deepEqual(args.slice(-2), ['-p', 'wiki-agents']);
+    assert.ok(args.includes('--env-file'));
+  });
+});
+
+test('a missing override and a missing .env are both valid', async () => {
+  await withManagerState({}, () => {
+    delete process.env.CONNECTORS_ENABLED;
+    const { args, composeFiles, profiles } = resolveAgentsComposeContext();
+    assert.equal(composeFiles.length, 1);
+    assert.deepEqual(profiles, []);
+    assert.equal(args.includes('--env-file'), false);
+  });
+});

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.28",
-  "commit": "11b99e6"
+  "version": "0.15.32",
+  "commit": "8b6b1aa"
 }