@dotdrelle/wiki-manager 0.15.28 → 0.15.29

package/src/core/env.js

@@ -39,18 +39,24 @@ export function managerMcpEndpointsFile() {
   return join(managerStateDir(), 'mcp.endpoints.json');
 }
 
-// User-owned compose overrides, one per stack, next to the manager .env.
-// Deliberately NOT under .wiki/runtime: everything there is generated state
-// that every compose command rewrites (see cacert.js). These two are seeded
-// once and never touched again, so an operator has a supported place to fix a
-// deployment — proxy passthrough, extra mounts, optional agents — instead of
-// editing a generated file and losing the change on the next command.
+// User-owned compose overrides, one per stack. `.wiki/compose` is persistent
+// operator configuration; `.wiki/runtime` is generated state rewritten by
+// compose commands. Keeping those directories separate makes the lifecycle
+// explicit while grouping manager-local files under one `.wiki` tree.
 export const COMPOSE_OVERRIDES = [
   { example: 'docker-compose.override.example.yml', target: 'docker-compose.override.yml' },
   { example: 'agents.docker-compose.override.example.yml', target: 'agents.docker-compose.override.yml' },
 ];
 
+export function managerComposeDir() {
+  return join(managerStateDir(), '.wiki', 'compose');
+}
+
 export function managerComposeOverrideFile(target = 'docker-compose.override.yml') {
+  return join(managerComposeDir(), target);
+}
+
+function legacyManagerComposeOverrideFile(target) {
   return join(managerStateDir(), target);
 }
 
@@ -160,12 +166,23 @@ export function ensureManagerScaffold({ log = () => {} } = {}) {
   for (const { example, target } of COMPOSE_OVERRIDES) {
     const examplePath = join(packageRoot, example);
     const targetPath = managerComposeOverrideFile(target);
+    const legacyPath = legacyManagerComposeOverrideFile(target);
+    mkdirSync(dirname(targetPath), { recursive: true });
+    if (!existsSync(targetPath) && existsSync(legacyPath)) {
+      renameSync(legacyPath, targetPath);
+      created.push(`.wiki/compose/${target} migrated`);
+      continue;
+    }
     if (!existsSync(examplePath) || existsSync(targetPath)) continue;
     copyFileSync(examplePath, targetPath);
-    created.push(target);
+    created.push(`.wiki/compose/${target}`);
   }
   if (created.length > 0) {
-    log(`configuration initialized successfully in ${managerStateDir()} — created ${created.join(' and ')} from packaged defaults. Optional credentials can be added later for external services.`);
+    // The list of seeded files and the state directory are implementation
+    // detail the operator has no decision to make about — the return value
+    // still carries them for callers that need to react (a fresh scaffold
+    // forces a runtime restart).
+    log('configuration initialized successfully');
   }
   return created;
 }
@@ -209,12 +226,12 @@ function parseEnvValue(value) {
   return value;
 }
 
-export function loadManagerEnv() {
+export function loadManagerEnv({ override = false } = {}) {
   const filePath = managerEnvFile();
   if (!existsSync(filePath)) return;
   const values = readEnvFile(filePath);
   for (const [key, value] of Object.entries(values)) {
-    if (!(key in process.env)) process.env[key] = value;
+    if (override || !(key in process.env)) process.env[key] = value;
   }
 }
 

package/src/core/mcp.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { managerEnvFile, managerMcpEndpointsFile, readEnvFile } from './env.js';
 
-const WIKI_MANAGER_VERSION = '0.15.28';
+const WIKI_MANAGER_VERSION = '0.15.29';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/startupCheck.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { promisify } from 'node:util';
 import { activeCacertPath, cacertEnv } from './cacert.js';
 import { COMPOSE_SERVICES, parseComposePsJson, serviceStates } from './compose.js';
+import { resolveAgentsComposeContext } from './agentsCompose.js';
 import { buildMcpStatus, discoverMcpTools } from './mcp.js';
 import { listWikircProfiles, loadWikircProfile, summarizeWikircConfig } from './wikirc.js';
 import { listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
@@ -79,22 +80,27 @@ export async function checkInternetConnectivity({
   }
 }
 
-async function checkAgents({ exec = execFileAsync } = {}) {
-  const composeFile = join(managerRoot(), 'agents.docker-compose.yml');
-  if (!existsSync(composeFile)) return null;
+export async function checkAgents({ exec = execFileAsync, context = resolveAgentsComposeContext() } = {}) {
+  if (!context.exists) return null;
   try {
-    const { stdout } = await exec('docker', [
-      'compose',
-      '--project-directory',
-      managerRoot(),
-      '-f',
-      composeFile,
-      '-p',
-      'wiki-agents',
-      'ps',
-      '--format',
-      'json',
-    ], {
+    // `config --services` is Compose's authoritative view after profiles,
+    // overrides and interpolation. Unlike `ps`, it also includes services that
+    // have never created a container, including ordinary (non-profiled)
+    // services and services contributed by the user override.
+    const { stdout: configuredStdout } = await exec(
+      'docker',
+      [...context.args, 'config', '--services'],
+      {
+        cwd: managerRoot(),
+        env: {
+          ...process.env,
+          WIKI_WORKSPACES_DIR: workspacesDir(),
+        },
+        timeout: 30_000,
+        maxBuffer: 1024 * 1024,
+      },
+    );
+    const { stdout } = await exec('docker', [...context.args, 'ps', '--all', '--format', 'json'], {
       cwd: managerRoot(),
       env: {
         ...process.env,
@@ -104,16 +110,38 @@ async function checkAgents({ exec = execFileAsync } = {}) {
       timeout: 5000,
       maxBuffer: 1024 * 1024,
     });
-    const entries = parseComposePsJson(stdout);
-    if (entries.length === 0) return null;
-    const downServices = entries
-      .filter((entry) => {
-        const state = String(entry.State ?? entry.state ?? entry.Status ?? entry.status ?? '').toLowerCase();
-        return !(state.includes('running') || state.includes('up'));
-      })
-      .map((entry) => entry.Service ?? entry.service ?? entry.Name ?? entry.name)
+    const expectedServices = String(configuredStdout ?? '')
+      .split(/\r?\n/)
+      .map((service) => service.trim())
       .filter(Boolean);
-    return downServices.length > 0 ? { kind: 'agents', context: { downServices } } : null;
+    const entries = parseComposePsJson(stdout);
+    const running = new Set();
+    const downServices = [];
+    for (const entry of entries) {
+      const name = entry.Service ?? entry.service ?? entry.Name ?? entry.name;
+      if (!name) continue;
+      const state = String(entry.State ?? entry.state ?? entry.Status ?? entry.status ?? '').toLowerCase();
+      if (state.includes('running') || state.includes('up')) running.add(name);
+      else downServices.push(name);
+    }
+    // A service whose profile the operator enabled but which `ps` does not list
+    // at all is missing, not opted out — reporting only the listed-but-stopped
+    // ones turned "connectors never started" into a silent success.
+    const missingServices = expectedServices.filter(
+      (service) => !running.has(service) && !downServices.includes(service),
+    );
+    if (entries.length === 0 && missingServices.length === 0) return null;
+    if (downServices.length === 0 && missingServices.length === 0) return null;
+    return {
+      kind: 'agents',
+      context: {
+        ...(downServices.length > 0 ? { downServices } : {}),
+        ...(missingServices.length > 0 ? { missingServices } : {}),
+        expectedServices,
+        requestedProfileServices: context.expectedProfileServices,
+        profiles: context.profiles,
+      },
+    };
   } catch (err) {
     if (err?.code === 'ENOENT') {
       return { kind: 'agents', context: { dockerMissing: true } };
@@ -349,16 +377,25 @@ export async function runChecks({
   if (!docker.ok) gaps.push({ kind: 'agents', context: docker.context ?? { dockerUnavailable: true } });
   if (!internet.ok) gaps.push({ kind: 'network', context: internet.context ?? {} });
   if (agents) gaps.push(agents);
+  const missingRequested = (agents?.context?.missingServices ?? []).filter(
+    (service) => (agents?.context?.requestedProfileServices ?? []).includes(service),
+  );
   onCheck({
     kind: 'agents',
     ok: docker.ok && !agents,
     skipped: !docker.ok,
     pending: !docker.ok || Boolean(agents),
+    // A service behind a profile the operator explicitly enabled is not merely
+    // "not started yet": they asked for it. Reporters use this to stay silent
+    // about ordinary boot latency while still surfacing this one.
+    requested: missingRequested.length > 0,
     detail: !docker.ok
       ? 'Waiting for Docker'
-      : agents?.context?.downServices?.length
-        ? `To start: ${agents.context.downServices.join(', ')}`
-        : 'Running',
+      : missingRequested.length > 0
+        ? `Enabled but not running: ${missingRequested.join(', ')}`
+        : agents?.context?.downServices?.length
+          ? `To start: ${agents.context.downServices.join(', ')}`
+          : 'Running',
     context: { ...(agents?.context ?? {}), command: 'wiki-workspace agents up' },
   });
   const workspaceGap = checkWorkspace(workspaces);

package/src/core/startupCheck.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 { checkInternetConnectivity, checkMcpConnections, runChecks, runPreflightChecks, withRuntimePreflight } from './startupCheck.js';
+import { checkAgents, checkInternetConnectivity, checkMcpConnections, runChecks, runPreflightChecks, withRuntimePreflight } from './startupCheck.js';
 
 async function withWorkspace(wikircLines, fn) {
   const root = await mkdtemp(join(tmpdir(), 'wiki-manager-startup-check-'));
@@ -34,6 +34,54 @@ function hasGap(gaps, kind) {
   return gaps.some((gap) => gap.kind === kind);
 }
 
+test('checkAgents reports an enabled profile whose container never appeared', async () => {
+  // `docker compose ps` lists nothing for a service that was never created, so
+  // filtering only on "listed but stopped" reported success while connectors
+  // was absent. An enabled profile is a promise, not an opt-out.
+  const context = {
+    exists: true,
+    args: ['compose', '-p', 'wiki-agents', '--profile', 'connectors'],
+    profiles: ['connectors'],
+    expectedProfileServices: ['connectors'],
+  };
+  const running = JSON.stringify([{ Service: 'cme', State: 'running' }]);
+  const execWithPs = (ps) => async (_command, args) => ({
+    stdout: args.includes('config') ? 'cme\nconnectors\n' : ps,
+  });
+
+  const gap = await checkAgents({ context, exec: execWithPs(running) });
+  assert.equal(gap.kind, 'agents');
+  assert.deepEqual(gap.context.missingServices, ['connectors']);
+  assert.deepEqual(gap.context.profiles, ['connectors']);
+
+  const started = JSON.stringify([
+    { Service: 'cme', State: 'running' },
+    { Service: 'connectors', State: 'running' },
+  ]);
+  assert.equal(await checkAgents({ context, exec: execWithPs(started) }), null);
+});
+
+test('checkAgents ignores a profile the operator did not enable', async () => {
+  const context = { exists: true, args: [], profiles: [], expectedProfileServices: [] };
+  const stdout = JSON.stringify([{ Service: 'cme', State: 'running' }]);
+  const exec = async (_command, args) => ({
+    stdout: args.includes('config') ? 'cme\n' : stdout,
+  });
+  assert.equal(await checkAgents({ context, exec }), null);
+});
+
+test('checkAgents reports an ordinary agent that never created a container', async () => {
+  const context = { exists: true, args: [], profiles: [], expectedProfileServices: [] };
+  const exec = async (_command, args) => ({
+    stdout: args.includes('config')
+      ? 'cme\ndocuments\n'
+      : JSON.stringify([{ Service: 'cme', State: 'running' }]),
+  });
+  const gap = await checkAgents({ context, exec });
+  assert.deepEqual(gap.context.missingServices, ['documents']);
+  assert.deepEqual(gap.context.expectedServices, ['cme', 'documents']);
+});
+
 test('runChecks treats default LLM config without baseUrl as incomplete', async () => {
   await withWorkspace([
     'llm:',

package/src/core/wikiSetup.js

@@ -6,15 +6,12 @@ import { promisify } from 'node:util';
 import YAML from 'yaml';
 import { checkMissingDockerImages } from './dockerImages.js';
 import { patchWikircProfile } from './wikirc.js';
-import { managerEnvFile, managerMcpEndpointsFile, readEnvFile, resolveAgentsDataDir } from './env.js';
+import { resolveAgentsComposeContext } from './agentsCompose.js';
+import { managerEnvFile, managerMcpEndpointsFile, resolveAgentsDataDir } from './env.js';
 import { createWorkspace, findWorkspace, isValidWorkspaceName, listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
 
 const execFileAsync = promisify(execFile);
 
-function enabled(value) {
-  return /^(?:1|true|yes|on)$/i.test(String(value ?? '').trim());
-}
-
 export function configuredAgentImages(config, activeProfiles = new Set()) {
   return Object.values(config.services ?? {})
     .filter((service) => {
@@ -25,21 +22,12 @@ export function configuredAgentImages(config, activeProfiles = new Set()) {
     .filter(Boolean);
 }
 
-async function missingAgentImages() {
-  let managerEnv = {};
-  try {
-    managerEnv = readEnvFile(managerEnvFile());
-  } catch {
-    // A missing manager .env is valid during first-run setup.
-  }
-  const activeProfiles = new Set();
-  if (enabled(managerEnv.CONNECTORS_ENABLED ?? process.env.CONNECTORS_ENABLED)) {
-    activeProfiles.add('connectors');
-  }
-  const composeFiles = [
-    join(managerRoot(), 'agents.docker-compose.yml'),
-    join(dirname(managerEnvFile()), 'agents.docker-compose.override.yml'),
-  ].filter(existsSync);
+async function missingAgentImages(context = resolveAgentsComposeContext()) {
+  // Same resolution as the preflight and as `wiki-workspace agents up`: an
+  // image behind a profile the operator did not enable must not be reported
+  // missing, and one behind a profile they DID enable must be.
+  const activeProfiles = new Set(context.profiles);
+  const composeFiles = context.composeFiles.filter(existsSync);
   const images = [...new Set(composeFiles.flatMap((filePath) => {
     try {
       const config = YAML.parse(readFileSync(filePath, 'utf8')) ?? {};
@@ -77,13 +65,22 @@ function wrapDockerError(err) {
 }
 
 export async function startAgents(options = {}) {
+  const composeContext = options.composeContext ?? resolveAgentsComposeContext();
   try {
-    const absentImages = await missingAgentImages();
+    const absentImages = options.imagesCheck
+      ? await options.imagesCheck(composeContext)
+      : await missingAgentImages(composeContext);
     if (absentImages.length > 0) options.onImagesMissing?.(absentImages);
-    const { stdout, stderr } = await execFileAsync(join(managerRoot(), 'wiki-workspace'), ['agents', 'up'], {
+    const exec = options.exec ?? execFileAsync;
+    const { stdout, stderr } = await exec(join(managerRoot(), 'wiki-workspace'), ['agents', 'up'], {
       cwd: managerRoot(),
       env: {
         ...process.env,
+        // Compose gives variables already exported by its parent process
+        // precedence over --env-file, including an empty value loaded at boot.
+        // Re-apply the manager's resolved policy here so a token/secret written
+        // later to .env is not shadowed by stale process.env state.
+        ...composeContext.env,
         WIKI_WORKSPACES_DIR: workspacesDir(),
         // cwd is the npm package root (the script and compose files live
         // there), so the manager files MUST be pinned explicitly: without
@@ -102,15 +99,53 @@ export async function startAgents(options = {}) {
       timeout: options.timeout ?? 180_000,
       maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
     });
+    // `wiki-workspace agents up` also (re)writes mcp.endpoints.json, so the
+    // endpoints must be re-read here — the caller's in-memory session still
+    // holds the file as it was BEFORE the connectors entry was added, and the
+    // freshly started agent would stay unreachable until the next restart.
+    const verification = await verifyAgentsStarted({
+      context: composeContext,
+      agentsCheck: options.agentsCheck,
+    });
+    if (!verification.ok) throw agentsStartFailure(verification);
     return {
       output: [stdout, stderr].filter(Boolean).join('\n').trim(),
       missingImages: absentImages,
+      profiles: composeContext.profiles,
     };
   } catch (err) {
     throw wrapDockerError(err);
   }
 }
 
+// A start that leaves an enabled service down is a failure. Reporting success
+// and letting the operator discover it through a silent preflight line is what
+// made CONNECTORS_ENABLED=true look like it had been ignored.
+async function verifyAgentsStarted({ context, agentsCheck }) {
+  const check = agentsCheck ?? (await import('./startupCheck.js')).checkAgents;
+  const gap = await check({ context });
+  if (!gap) return { ok: true, profiles: context.profiles };
+  const down = gap.context?.downServices ?? [];
+  const missing = gap.context?.missingServices ?? [];
+  if (down.length === 0 && missing.length === 0) return { ok: true, profiles: context.profiles };
+  return { ok: false, downServices: down, missingServices: missing, profiles: context.profiles };
+}
+
+function agentsStartFailure({ downServices = [], missingServices = [], profiles = [] }) {
+  const parts = [
+    missingServices.length > 0 ? `never started: ${missingServices.join(', ')}` : '',
+    downServices.length > 0 ? `not running: ${downServices.join(', ')}` : '',
+  ].filter(Boolean);
+  const error = new Error(
+    `Agents started, but the expected services are not up (${parts.join('; ')}).`
+    + (profiles.length > 0 ? ` Active profiles: ${profiles.join(', ')}.` : ''),
+  );
+  error.name = 'AgentsNotRunningError';
+  error.downServices = downServices;
+  error.missingServices = missingServices;
+  return error;
+}
+
 export async function stopAgents(options = {}) {
   try {
     const { stdout, stderr } = await execFileAsync(join(managerRoot(), 'wiki-workspace'), ['agents', 'down'], {

package/src/core/wikiSetup.test.js

@@ -0,0 +1,87 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { startAgents } from './wikiSetup.js';
+
+const CONTEXT = {
+  exists: true,
+  args: [],
+  profiles: ['connectors'],
+  expectedProfileServices: ['connectors'],
+  composeFiles: [],
+};
+
+function startOptions(overrides = {}) {
+  return {
+    composeContext: CONTEXT,
+    imagesCheck: async () => [],
+    exec: async () => ({ stdout: 'started', stderr: '' }),
+    ...overrides,
+  };
+}
+
+test('starting the agents succeeds when every enabled service is running', async () => {
+  const result = await startAgents(startOptions({ agentsCheck: async () => null }));
+  assert.equal(result.output, 'started');
+  assert.deepEqual(result.profiles, ['connectors']);
+});
+
+test('an enabled connector that never started makes the start fail, not succeed', async () => {
+  // The script exits 0 whether or not the profiled container came up, so
+  // trusting its exit code alone reported success while connectors was absent
+  // — the operator only found out much later, through a silent preflight line.
+  await assert.rejects(
+    startAgents(startOptions({
+      agentsCheck: async () => ({ kind: 'agents', context: { missingServices: ['connectors'], profiles: ['connectors'] } }),
+    })),
+    (err) => {
+      assert.equal(err.name, 'AgentsNotRunningError');
+      assert.deepEqual(err.missingServices, ['connectors']);
+      assert.match(err.message, /never started: connectors/);
+      assert.match(err.message, /Active profiles: connectors\./);
+      return true;
+    },
+  );
+});
+
+test('a listed but stopped service also fails the start', async () => {
+  await assert.rejects(
+    startAgents(startOptions({
+      agentsCheck: async () => ({ kind: 'agents', context: { downServices: ['cme'] } }),
+    })),
+    (err) => {
+      assert.equal(err.name, 'AgentsNotRunningError');
+      assert.deepEqual(err.downServices, ['cme']);
+      assert.match(err.message, /not running: cme/);
+      return true;
+    },
+  );
+});
+
+test('the verification runs against the same compose context as the start', async () => {
+  let seen = null;
+  await startAgents(startOptions({
+    agentsCheck: async ({ context }) => { seen = context; return null; },
+  }));
+  assert.equal(seen, CONTEXT);
+});
+
+test('the manager .env values override stale blank process values for agents up', async () => {
+  let childEnv = null;
+  const context = {
+    ...CONTEXT,
+    env: {
+      ...process.env,
+      GOOGLE_OAUTH_CLIENT_SECRET: 'fresh-secret',
+    },
+  };
+  await startAgents(startOptions({
+    composeContext: context,
+    agentsCheck: async () => null,
+    exec: async (_file, _args, options) => {
+      childEnv = options.env;
+      return { stdout: 'started', stderr: '' };
+    },
+  }));
+  assert.equal(childEnv.GOOGLE_OAUTH_CLIENT_SECRET, 'fresh-secret');
+});

package/src/orchestrator/objectiveResolver.js

@@ -1,3 +1,18 @@
+// Distinguishes "nothing here can do that" from a genuine resolution failure:
+// the first is a normal answer Donna gives the user, the second is a defect.
+export class ObjectiveNotOrchestrableError extends Error {
+  constructor(objective, candidates = [], reason = '') {
+    const available = candidates.map((item) => item.id).join(', ') || 'none';
+    super(
+      `No connected agent can do that.${reason ? ` ${String(reason).trim()}` : ''}`
+      + ` Available capabilities: ${available}.`,
+    );
+    this.name = 'ObjectiveNotOrchestrableError';
+    this.objective = String(objective ?? '');
+    this.candidates = candidates.map((item) => item.id);
+  }
+}
+
 export async function resolveObjective(objective, session) {
   const candidates = capabilityCandidates(session);
   if (candidates.length === 0) throw new Error('No orchestrable capability is currently available.');
@@ -10,6 +25,12 @@ export async function resolveObjective(objective, session) {
     system: [
       'You resolve one user objective against a closed capability registry.',
       'Select exactly one listed capability and one of its supported operations.',
+      // Without an explicit way out, the model has to pick SOMETHING: an
+      // objective no listed capability covers ("authorize Gmail") came back as
+      // workspace.diagnose/doctor and launched an unrelated job. Declining is
+      // a valid answer and the caller turns it into a plain reply.
+      'If no listed capability can achieve the objective, do not pick the closest one:',
+      'return {"capability":null,"reason":"<short reason>"}.',
       'Never invent identifiers. Return JSON only: {"capability":"...","operation":"..."}.',
     ].join('\n'),
     tools: [],
@@ -20,6 +41,9 @@ export async function resolveObjective(objective, session) {
     signal: session?._abortSignal,
   });
   const selection = parseJson(result?.content);
+  if (selection?.capability === null) {
+    throw new ObjectiveNotOrchestrableError(objective, candidates, selection?.reason);
+  }
   const capability = String(selection?.capability ?? '');
   const operation = String(selection?.operation ?? '');
   const candidate = candidates.find((item) => item.id === capability);

package/src/orchestrator/objectiveResolver.test.js

@@ -64,6 +64,33 @@ test('resolveObjective uses an unambiguously mentioned registry operation withou
   assert.equal(result.provider.agentInstanceId, 'production-1');
 });
 
+test('resolveObjective declines an objective no listed capability covers', async () => {
+  // Forcing a pick is how "cree l'auth pour le gmail" became a doctor run on
+  // the production agent. Declining must be reported as such, not as a defect.
+  const session = sessionWithSelection({ capability: null, reason: 'Gmail authorization is not an orchestrable capability.' });
+  await assert.rejects(
+    resolveObjective("cree l'auth pour le gmail", session),
+    (err) => {
+      assert.equal(err.name, 'ObjectiveNotOrchestrableError');
+      assert.match(err.message, /No connected agent can do that\./);
+      assert.match(err.message, /Available capabilities: knowledge\.update\./);
+      assert.deepEqual(err.candidates, ['knowledge.update']);
+      return true;
+    },
+  );
+});
+
+test('resolveObjective treats a malformed selection as a resolution defect, not a decline', async () => {
+  await assert.rejects(
+    resolveObjective('Traite tout', sessionWithSelection({ reason: 'missing capability' })),
+    (err) => {
+      assert.notEqual(err.name, 'ObjectiveNotOrchestrableError');
+      assert.match(err.message, /unknown capability/);
+      return true;
+    },
+  );
+});
+
 test('resolveObjective rejects invented capability and operation', async () => {
   await assert.rejects(
     resolveObjective('Traite tout', sessionWithSelection({ capability: 'ingest', operation: 'ingest_all_pending' })),