@dotdrelle/wiki-manager 0.14.20 → 0.14.23

package/src/agent/graph.test.js

@@ -403,7 +403,8 @@ test('Donna refuses to delegate connector authentication to an export capability
   globalThis.fetch = async (url, options = {}) => {
     fetchedUrls.push(String(url));
     const body = JSON.parse(String(options.body ?? '{}'));
-    assert.equal(body.params?.name, 'start_google_auth');
+    assert.equal(body.params?.name, 'connectors_google_oauth_start');
+    assert.deepEqual(body.params?.arguments, { workspace: 'docs' });
     return {
       ok: true,
       status: 200,
@@ -415,16 +416,16 @@ test('Donna refuses to delegate connector authentication to an export capability
   const session = sessionBase({
     runtime: { url: 'http://runtime.test' },
     mcp: {
-      'google-workspace': {
+      connectors: {
         status: 'connected',
         url: 'http://google.test/mcp',
         tools: [
           {
-            name: 'start_google_auth',
+            name: 'connectors_google_oauth_start',
             description: 'Manually initiate Google OAuth authentication flow.',
             inputSchema: { type: 'object', additionalProperties: true },
           },
-          { name: 'search_gmail_messages', inputSchema: { type: 'object', additionalProperties: true } },
+          { name: 'connectors_google_status', inputSchema: { type: 'object', additionalProperties: true } },
         ],
       },
     },
@@ -439,7 +440,7 @@ test('Donna refuses to delegate connector authentication to an export capability
         if (turn === 2) return {
           content: null,
           message: { role: 'assistant', content: null },
-          tool_calls: [{ id: 'google-auth', type: 'function', function: { name: 'google-workspace__start_google_auth', arguments: '{}' } }],
+          tool_calls: [{ id: 'google-auth', type: 'function', function: { name: 'connectors__connectors_google_oauth_start', arguments: '{}' } }],
         };
         return {
           content: 'J’ai lancé l’authentification. Ouvre le lien fourni.',
@@ -1146,7 +1147,8 @@ test('agent graph accepts plan steps with known capabilities and null capability
 test('buildAgentSystemPrompt assigns capability resolution exclusively to the runtime', () => {
   const withAgents = buildAgentSystemPrompt({ session: sessionBase({ agentRegistrySnapshot: orchestrableAgentSnapshot() }) });
   assert.match(withAgents, /call runtime__delegate with the user objective only/);
-  assert.match(withAgents, /Never choose a capability, operation, agent, plan, or implementation yourself/);
+  assert.match(withAgents, /executor-only single-task agents/);
+  assert.match(withAgents, /Never choose those identifiers yourself/);
   assert.doesNotMatch(withAgents, /ONLY values allowed in requiredCapability/);
 });
 
@@ -1310,6 +1312,106 @@ test('runtime action retries a text-only hallucination and requires a real tool
   }
 });
 
+test('interactive action delegates after a connector status check did not execute the requested collection', async () => {
+  const originalFetch = globalThis.fetch;
+  let delegatedObjective = null;
+  globalThis.fetch = async (url, options = {}) => {
+    if (String(url).includes('/delegate')) {
+      const body = JSON.parse(String(options.body ?? '{}'));
+      delegatedObjective = body.objective;
+      return {
+        ok: true,
+        status: 202,
+        json: async () => ({
+          accepted: true,
+          runId: 'collect-run',
+          delegation: { tasks: 1, agent: 'connectors' },
+        }),
+      };
+    }
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      text: async () => JSON.stringify({
+        result: { content: [{ type: 'text', text: '{"ok":true,"status":"configured"}' }] },
+      }),
+    };
+  };
+  let modelCalls = 0;
+  const session = sessionBase({
+    runtime: { url: 'http://runtime.test' },
+    mcp: {
+      connectors: {
+        status: 'connected',
+        url: 'http://connectors.test/mcp/',
+        tools: [{
+          name: 'connectors_google_status',
+          description: 'Read Google authorization status.',
+          inputSchema: { type: 'object', properties: { workspace: { type: 'string' } } },
+        }],
+      },
+    },
+    llm: {
+      async completeWithTools({ tools }) {
+        if (tools.some((tool) => tool.function.name === 'classify_action_request')) {
+          return {
+            content: null,
+            tool_calls: [{
+              id: 'classification',
+              type: 'function',
+              function: { name: 'classify_action_request', arguments: '{"action":true}' },
+            }],
+          };
+        }
+        modelCalls += 1;
+        if (modelCalls === 1) {
+          return {
+            content: null,
+            message: { role: 'assistant', content: null },
+            tool_calls: [{
+              id: 'status',
+              type: 'function',
+              function: { name: 'connectors__connectors_google_status', arguments: '{"workspace":"docs"}' },
+            }],
+          };
+        }
+        if (modelCalls === 2) {
+          return {
+            content: 'Le statut est configuré mais je ne peux pas collecter.',
+            message: { role: 'assistant', content: 'Le statut est configuré mais je ne peux pas collecter.' },
+            tool_calls: null,
+          };
+        }
+        if (modelCalls === 3) {
+          return {
+            content: null,
+            message: { role: 'assistant', content: null },
+            tool_calls: [{
+              id: 'delegate',
+              type: 'function',
+              function: { name: 'runtime__delegate', arguments: '{"objective":"charge les 10 derniers mails"}' },
+            }],
+          };
+        }
+        return {
+          content: 'Collecte lancée.',
+          message: { role: 'assistant', content: 'Collecte lancée.' },
+          tool_calls: null,
+        };
+      },
+    },
+  });
+
+  try {
+    const result = await createAgentGraph().invoke({ input: 'charge les 10 derniers mails', session });
+    assert.equal(delegatedObjective, 'charge les 10 derniers mails');
+    assert.equal(result.response, 'Collecte lancée.');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
 test('agent graph auto-declares the plan from an agent_plan task-graph fragment', async () => {
   // The bridge that makes parallel ingestion real: when the LLM calls
   // production__agent_plan, the shell integrates the fragment as the plan

package/src/cli/runtimeStartup.test.js

@@ -0,0 +1,14 @@
+import { readFile } from 'node:fs/promises';
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+test('runtime startup is not blocked by optional Docker image maintenance', async () => {
+  const source = await readFile(new URL('./wiki-manager.js', import.meta.url), 'utf8');
+  const runtimeBranch = source.slice(
+    source.indexOf("if (argv[0] === 'runtime')"),
+    source.indexOf("if (argv.includes('--setup-wizard'))"),
+  );
+
+  assert.match(runtimeBranch, /await runRuntime\(argv\.slice\(1\), agent\)/);
+  assert.doesNotMatch(runtimeBranch, /refreshRunningContainers/);
+});

package/src/cli/wiki-manager.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
@@ -25,7 +26,7 @@ import { listWorkspaces } from '../core/workspaces.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageJsonPath = resolve(__dirname, '../../package.json');
 const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-const SHELL_COMMANDS = ['help', 'version', 'exit', 'workspace', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'wiki', 'skills', 'clear', 'chat', 'agent', 'approve'];
+const SHELL_COMMANDS = ['help', 'version', 'exit', 'workspace', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'connector', 'wiki', 'skills', 'clear', 'chat', 'agent', 'approve'];
 
 function valueAfter(argv, flag) {
   const index = argv.indexOf(flag);
@@ -54,6 +55,144 @@ function unavailableRuntime(err) {
   return { url: null, error: reason };
 }
 
+export function buildExecutorOnlyFragment({ objective, workspace, selection }) {
+  const provider = selection.provider;
+  const capability = provider.capability ?? {};
+  const agentInstanceId = String(provider.agentInstanceId ?? provider.serverName);
+  const label = String(objective ?? '').trim() || `${selection.operation} ${selection.capability}`;
+  const mutationClass = typeof capability.mutationClass === 'string'
+    ? capability.mutationClass
+    : null;
+  const requiresApproval = capability.defaultRequiresApproval === true || Boolean(mutationClass);
+  return {
+    contractVersion: String(provider.description?.contractVersion ?? '1'),
+    agentInstanceId,
+    capability: selection.capability,
+    summary: {
+      label,
+      initialSynthesis: [],
+      estimatedTasks: 1,
+    },
+    groups: [],
+    tasks: [{
+      id: `${selection.operation}-${randomUUID()}`,
+      label,
+      requiredCapability: selection.capability,
+      operation: selection.operation,
+      arguments: selection.arguments ?? {},
+      dependsOn: [],
+      parallelizable: false,
+      inputRefs: [],
+      expectedOutputRefs: [],
+      locks: [`${selection.capability}:${String(workspace)}`],
+      requiresApproval,
+      ...(mutationClass ? { approvalClass: mutationClass } : {}),
+      ...(requiresApproval ? { approvalSummary: label } : {}),
+      idempotencyKey: randomUUID(),
+      progressWeight: 1,
+    }],
+    expectedOutputs: [],
+  };
+}
+
+/**
+ * Fill a single-task executor's arguments from the natural-language objective,
+ * generically — against the capability's own declared `inputSchema`, with no
+ * per-agent or per-provider knowledge in the manager. This lets Donna honour
+ * stated constraints ("les 10 derniers mails", "de LinkedIn") while keeping
+ * `runtime__delegate` agnostic (it still only carries the objective).
+ *
+ * Degrades gracefully (cf. provider compatibility): forced tool_choice first,
+ * then a JSON-text completion, then no arguments — the executor uses its own
+ * defaults. It never throws and never invents identifiers.
+ */
+export async function resolveExecutorArguments({ llm, objective, capability, signal } = {}) {
+  const schema = capability?.inputSchema;
+  const objectiveText = String(objective ?? '').trim();
+  if (
+    !objectiveText
+    || !llm
+    || typeof llm.completeWithTools !== 'function'
+    || !schema
+    || typeof schema !== 'object'
+    || !schema.properties
+    || typeof schema.properties !== 'object'
+    || Object.keys(schema.properties).length === 0
+  ) {
+    return {};
+  }
+  const system = [
+    'Extract structured arguments for a task from the user objective.',
+    'Only fill a field when the objective explicitly states or clearly implies its value.',
+    'Omit every field that is not stated. Never invent identifiers, queries, filters or counts.',
+    'Return the arguments object only.',
+  ].join('\n');
+  const tool = {
+    type: 'function',
+    function: {
+      name: 'set_task_arguments',
+      description: String(capability.description ?? 'Task arguments for the selected capability.'),
+      parameters: {
+        type: 'object',
+        additionalProperties: schema.additionalProperties ?? false,
+        properties: schema.properties,
+      },
+    },
+  };
+  const messages = [{ role: 'user', content: objectiveText }];
+  try {
+    const result = await llm.completeWithTools({
+      system,
+      tools: [tool],
+      toolChoice: { type: 'function', function: { name: 'set_task_arguments' } },
+      messages,
+      signal,
+    });
+    const call = (result?.tool_calls ?? []).find((item) => item?.function?.name === 'set_task_arguments');
+    const fromCall = call ? safeParseArgumentObject(call.function?.arguments) : null;
+    if (fromCall) return pruneArgumentsToSchema(fromCall, schema);
+    const fromText = safeParseArgumentObject(result?.content);
+    if (fromText) return pruneArgumentsToSchema(fromText, schema);
+  } catch {
+    // Fall through to the tool-less path.
+  }
+  try {
+    const result = await llm.completeWithTools({
+      system: `${system}\nReturn a single JSON object only.`,
+      tools: [],
+      messages,
+      signal,
+    });
+    const fromText = safeParseArgumentObject(result?.content);
+    if (fromText) return pruneArgumentsToSchema(fromText, schema);
+  } catch {
+    // Give up: the executor will use its own defaults.
+  }
+  return {};
+}
+
+function safeParseArgumentObject(text) {
+  const cleaned = String(text ?? '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+  if (!cleaned) return null;
+  try {
+    const value = JSON.parse(cleaned);
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function pruneArgumentsToSchema(value, schema) {
+  const allowed = schema.properties ?? {};
+  const acceptsExtra = schema.additionalProperties !== false;
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry === undefined || entry === null) continue;
+    if (Object.hasOwn(allowed, key) || acceptsExtra) out[key] = entry;
+  }
+  return out;
+}
+
 function createSession() {
   return {
     workspace: null,
@@ -831,34 +970,60 @@ async function runRuntime(argv, agent) {
     }
     const provider = selection.provider;
     let planResult;
-    try {
-      planResult = await callMcpTool(
-        session.mcp,
-        provider.serverName,
-        'agent_plan',
-        {
-          capability: selection.capability,
-          operation: selection.operation,
-          objective,
-          workspace: { revision: String(Date.now()) },
-          constraints: {
-            maxConcurrency: resolveCapabilityConcurrency(
-              provider,
-              undefined,
-              process.env.WIKI_MANAGER_CAPABILITY_CONCURRENCY,
-            ),
-            requireApprovalForMutations: true,
+    const orchestration = provider.description?.orchestration ?? {};
+    const canPlan = orchestration.canPlan !== false;
+    const singleTaskExecutor = orchestration.canPlan === false
+      && orchestration.singleTaskOnly === true;
+    let fragment;
+    if (canPlan) {
+      try {
+        planResult = await callMcpTool(
+          session.mcp,
+          provider.serverName,
+          'agent_plan',
+          {
+            capability: selection.capability,
+            operation: selection.operation,
+            objective,
+            workspace: { revision: String(Date.now()) },
+            constraints: {
+              maxConcurrency: resolveCapabilityConcurrency(
+                provider,
+                undefined,
+                process.env.WIKI_MANAGER_CAPABILITY_CONCURRENCY,
+              ),
+              requireApprovalForMutations: true,
+            },
           },
+        );
+      } catch (err) {
+        const endpoint = session.mcp?.[provider.serverName]?.url ?? 'unknown endpoint';
+        throw new Error(
+          `Delegation failed during agent_plan: provider=${provider.serverName} endpoint=${endpoint} ${errorDiagnostic(err)}`,
+          { cause: err },
+        );
+      }
+      fragment = parseJsonText(formatMcpToolResult(planResult));
+    } else if (singleTaskExecutor) {
+      const extractedArguments = await resolveExecutorArguments({
+        llm: session.llm,
+        objective,
+        capability: provider.capability,
+        signal: session._abortSignal,
+      });
+      fragment = buildExecutorOnlyFragment({
+        objective,
+        workspace: session.workspace ?? context.workspace ?? 'workspace',
+        selection: {
+          ...selection,
+          arguments: { ...(selection.arguments ?? {}), ...extractedArguments },
         },
-      );
-    } catch (err) {
-      const endpoint = session.mcp?.[provider.serverName]?.url ?? 'unknown endpoint';
+      });
+    } else {
       throw new Error(
-        `Delegation failed during agent_plan: provider=${provider.serverName} endpoint=${endpoint} ${errorDiagnostic(err)}`,
-        { cause: err },
+        `Agent ${provider.agentInstanceId ?? provider.serverName} cannot plan and does not declare singleTaskOnly:true.`,
       );
     }
-    const fragment = parseJsonText(formatMcpToolResult(planResult));
     if (!Array.isArray(fragment?.tasks) || fragment.tasks.length === 0) {
       throw new Error(fragment?.summary?.initialSynthesis?.[0] ?? `No task was planned for ${selection.capability}/${selection.operation}.`);
     }
@@ -1204,10 +1369,6 @@ export async function runCli(argv) {
   if (argv[0] === 'runtime') {
     const scaffolded = ensureManagerScaffold({ log: (message) => console.log(`[wiki-manager] ${message}`) });
     if (scaffolded.length > 0) loadManagerEnv();
-    const imageRefresh = await refreshRunningContainers({
-      onStep: (message) => console.log(`[wiki-manager] ${message}`),
-    });
-    logImageRefreshErrors(imageRefresh);
     const agent = createAgentGraph();
     await runRuntime(argv.slice(1), agent);
     return;
@@ -1266,7 +1427,7 @@ export async function runCli(argv) {
     }
     const { runOpenTuiShell, runStartupWizard } = await import('../shell/tui.tsx');
     // Fresh directory → copy mcp.endpoints.json/.env from the packaged
-    // examples so external agents (cme, mailer, documents) connect out of
+    // examples so external agents (cme and documents) connect out of
     // the box. Done here (and in `runtime`), NOT at import time: --version
     // in a random cwd must not litter files.
     const scaffolded = ensureManagerScaffold({ log: (message) => console.log(`[wiki-manager] ${message}`) });

package/src/cli/wiki-manager.test.js

@@ -1,10 +1,101 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import {
+  buildExecutorOnlyFragment,
   forwardRuntimeApproval,
+  resolveExecutorArguments,
   resolvePreparedDelegationApproval,
 } from './wiki-manager.js';
 
+const COLLECT_CAPABILITY = {
+  description: 'Collect content from an external connector source.',
+  inputSchema: {
+    type: 'object',
+    additionalProperties: true,
+    properties: {
+      maxMessages: { type: 'integer' },
+      query: { type: 'string' },
+    },
+  },
+};
+
+test('executor-only capabilities receive one manager-authored executable task', () => {
+  const fragment = buildExecutorOnlyFragment({
+    objective: 'donne-moi mes derniers mails',
+    workspace: 'juno',
+    selection: {
+      capability: 'external-source.collect',
+      operation: 'collect',
+      arguments: { maxMessages: 10 },
+      provider: {
+        serverName: 'connectors',
+        agentInstanceId: 'connectors-1',
+        description: {
+          contractVersion: '1',
+          orchestration: { canPlan: false, singleTaskOnly: true },
+        },
+        capability: {
+          mutationClass: 'external-source',
+          defaultRequiresApproval: true,
+        },
+      },
+    },
+  });
+
+  assert.equal(fragment.agentInstanceId, 'connectors-1');
+  assert.equal(fragment.tasks.length, 1);
+  assert.equal(fragment.tasks[0].requiredCapability, 'external-source.collect');
+  assert.equal(fragment.tasks[0].operation, 'collect');
+  assert.deepEqual(fragment.tasks[0].arguments, { maxMessages: 10 });
+  assert.deepEqual(fragment.tasks[0].locks, ['external-source.collect:juno']);
+  assert.equal(fragment.tasks[0].requiresApproval, true);
+  assert.equal(fragment.tasks[0].approvalClass, 'external-source');
+  assert.match(fragment.tasks[0].idempotencyKey, /^[0-9a-f-]{36}$/);
+});
+
+test('generic argument extraction fills the executor task from the objective', async () => {
+  const llm = {
+    completeWithTools: async () => ({
+      tool_calls: [{
+        function: { name: 'set_task_arguments', arguments: JSON.stringify({ maxMessages: 10 }) },
+      }],
+    }),
+  };
+  const args = await resolveExecutorArguments({
+    llm,
+    objective: 'récupère les 10 derniers mails',
+    capability: COLLECT_CAPABILITY,
+  });
+  assert.deepEqual(args, { maxMessages: 10 });
+});
+
+test('argument extraction falls back to a JSON-text completion', async () => {
+  const llm = {
+    completeWithTools: async ({ tools }) =>
+      tools.length > 0 ? { content: '' } : { content: '{"query":"from:linkedin.com"}' },
+  };
+  const args = await resolveExecutorArguments({
+    llm,
+    objective: 'les mails de LinkedIn',
+    capability: COLLECT_CAPABILITY,
+  });
+  assert.deepEqual(args, { query: 'from:linkedin.com' });
+});
+
+test('argument extraction stays agnostic and safe when it cannot extract', async () => {
+  // No inputSchema → no extraction attempted at all.
+  assert.deepEqual(
+    await resolveExecutorArguments({ llm: { completeWithTools: async () => ({}) }, objective: 'x', capability: {} }),
+    {},
+  );
+  // Provider/LLM failure degrades to the executor's own defaults, never throws.
+  const throwing = { completeWithTools: async () => { throw new Error('gateway rejected tool_choice'); } };
+  assert.deepEqual(
+    await resolveExecutorArguments({ llm: throwing, objective: 'les 10 derniers mails', capability: COLLECT_CAPABILITY }),
+    {},
+  );
+});
+
 test('runtime approval bridge preserves the complete run-scoped grant', async () => {
   let forwarded = null;
   const request = {

package/src/commands/slash.js

@@ -631,6 +631,7 @@ ${helpPair('/skills', 'List skills', '/skills show <n>', 'Show skill')}
 ${helpPair('/skills run <n>', 'Run skill guide', '/skills edit <n>', 'Edit skill')}
 ${helpPair('/mcp status', 'MCP status', '/mcp endpoints', 'MCP endpoints')}
 ${helpPair('/mcp tools [mcp]', 'MCP tools', '/mcp call ...', 'Call MCP tool')}
+${helpPair('/connector list', 'Connector auth status', '/connector auth <n>', 'Authorize connector')}
 ${helpPair('/upload <path>', 'Upload document', '/uploads', 'Uploaded docs')}
 ${helpPair('/upload convert pending', 'Convert pending', '/uploads clean', 'Clean uploads')}
 ${helpPair('/wiki', 'Run wiki index', '/wiki run <args>', 'Raw wiki CLI')}
@@ -1025,6 +1026,63 @@ export async function handleSlashCommand(line, context) {
       }
       return { output: 'Usage: /mcp <status|endpoints|tools|call> [mcp]' };
     }
+    case 'connector': {
+      const subcommand = args[1] ?? 'list';
+      const connectorResult = (output) => rawCommandResult(`/connector ${args.slice(1).join(' ')}`.trim(), output);
+      if (!context.session.workspace) {
+        return connectorResult('No workspace is currently loaded.');
+      }
+      await refreshMcpRuntimeStatus(context.session);
+      const connectorMcp = context.session.mcp?.connectors;
+      if (!connectorMcp || connectorMcp.status !== 'connected') {
+        return connectorResult('The connectors service is unavailable or disabled.');
+      }
+      if (subcommand === 'list') {
+        if (args[2]) return connectorResult('The connector list request has invalid extra arguments.');
+        try {
+          const result = await callMcpTool(
+            context.session.mcp,
+            'connectors',
+            'connectors_google_status',
+            { workspace: context.session.workspace },
+          );
+          const payload = parseJsonText(formatMcpToolResult(result));
+          const status = payload?.status === 'configured' ? 'authorized' : 'not authorized';
+          return connectorResult(`google (Gmail read-only): ${status}`);
+        } catch (err) {
+          return connectorResult(`google (Gmail read-only): 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).');
+        }
+        try {
+          const result = await callMcpTool(
+            context.session.mcp,
+            'connectors',
+            'connectors_google_oauth_start',
+            { workspace: context.session.workspace },
+          );
+          const payload = parseJsonText(formatMcpToolResult(result));
+          const authorizationUrl = payload?.authorizationUrl;
+          if (payload?.ok !== true || typeof authorizationUrl !== 'string') {
+            return connectorResult(`Google authorization could not start (${payload?.error ?? 'missing authorization URL'}).`);
+          }
+          const opener = process.platform === 'darwin' ? 'open' : 'xdg-open';
+          try {
+            execFileSync(opener, [authorizationUrl], { stdio: 'ignore' });
+            return connectorResult('Google authorization opened successfully in the user browser.');
+          } catch {
+            return connectorResult(`Google authorization requires the user to open this URL: ${authorizationUrl}`);
+          }
+        } 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.');
+    }
     case 'cancel': {
       // Alias of /run cancel — people type /cancel when they want out.
       const runtime = context.runtime ?? {};

package/src/commands/slash.test.js

@@ -93,6 +93,24 @@ test('/new without a name shows usage', async () => {
   assert.match(result.output ?? '', /Usage/i);
 });
 
+test('/connector completions expose list and Google authorization', () => {
+  const session = { commands: ['connector'] };
+  assert.deepEqual(completionContext('/connector ', session)?.matches, ['auth', 'list']);
+  assert.deepEqual(completionContext('/connector auth ', session)?.matches, ['google']);
+});
+
+test('/connector hands deterministic facts to Donna for localized natural-language output', async () => {
+  const result = await handleSlashCommand('/connector list', {
+    packageJson: { version: 'test' },
+    session: {},
+  });
+
+  assert.equal(result.rawOutput, true);
+  assert.match(result.output ?? '', /No workspace is currently loaded/);
+  assert.match(result.agentTrigger ?? '', /profil workspace/);
+  assert.match(result.agentTrigger ?? '', /Ne relance pas la commande/);
+});
+
 test('/skills run sends the private skill body to Donna without rendering it as command output', async () => {
   const root = await mkdtemp(join(tmpdir(), 'wiki-manager-skill-run-'));
   const skillDir = join(root, '.wiki', 'skills');

package/src/core/activity.js

@@ -13,7 +13,7 @@ function basename(value) {
 }
 
 function terminalStatus(status) {
-  return ['done', 'failed', 'cancelled', 'canceled', 'complete', 'completed', 'success', 'error'].includes(String(status ?? '').toLowerCase());
+  return ['done', 'failed', 'cancelled', 'canceled', 'complete', 'completed', 'success', 'succeeded', 'error'].includes(String(status ?? '').toLowerCase());
 }
 
 export function activityKey(activity) {

package/src/core/activity.test.js

@@ -29,6 +29,11 @@ test('normalizeActivity: plan null when no plan field', () => {
   assert.equal(a.plan, null);
 });
 
+test('normalizeActivity: succeeded is terminal', () => {
+  const a = normalizeActivity({ id: 'job-connectors', status: 'succeeded' });
+  assert.equal(a.terminal, true);
+});
+
 test('isCancelledStatus recognizes both cancellation spellings', () => {
   assert.equal(isCancelledStatus('cancelled'), true);
   assert.equal(isCancelledStatus('canceled'), true);

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.14.20",
-  "commit": "8833a7e"
+  "version": "0.14.23",
+  "commit": "f0519ef"
 }