@dotdrelle/wiki-manager 0.14.16 → 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,
@@ -114,6 +253,18 @@ export async function forwardRuntimeApproval(getWorkspaceContext, request = {})
   return context.approvalManager?.approve(request) ?? { approved: false };
 }
 
+export function resolvePreparedDelegationApproval({
+  autoApprove = false,
+  approvalManager = null,
+  runId,
+} = {}) {
+  if (autoApprove !== true || typeof approvalManager?.approve !== 'function') {
+    return { approved: false, awaitingApproval: true };
+  }
+  const result = approvalManager.approve({ scope: 'run', runId });
+  return { approved: true, awaitingApproval: false, result };
+}
+
 function timestampForFile() {
   return new Date().toISOString().replace(/[:.]/g, '-');
 }
@@ -819,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}.`);
     }
@@ -923,14 +1100,24 @@ async function runRuntime(argv, agent) {
           throw new Error(`Delegated plan integration failed: ${(integrated.errors ?? []).map((error) => error.message ?? error.code ?? String(error)).join('; ')}`);
         }
         emitRuntimeLog(session, `delegation: ${prepared.fragment.tasks.length} validated task(s) integrated from ${prepared.provider.serverName}.agent_plan (${prepared.capability}/${prepared.operation})`);
-        // Demandé = consenti: a directly-delegated run carries the user's
-        // explicit consent, so auto-approve its initial plan. Persisting a
-        // run-scope grant (via the approval manager) makes the scheduler's
-        // readyTasks approval check pass, so the tasks run without re-prompting.
-        // Replanned tasks are integrated later without a fresh grant.
-        if (context.approvalManager?.approve) {
-          context.approvalManager.approve({ scope: 'run', runId });
-          emitRuntimeLog(session, `approval: run ${runId} auto-approved (user-requested action)`);
+        // Real approval gate (opt-out): a directly-delegated run only skips the
+        // human approval step when the caller explicitly opts in via
+        // `autoApprove` (e.g. headless/CI, or a future "trust this run" toggle).
+        // By default the run WAITS: integrate() above created the per-task
+        // approval requests, and the scheduler's approvalCovered() filter blocks
+        // the mutating tasks until a run-scope grant arrives (/approve or
+        // "valide tout"). This keeps a visible pending_approval window instead of
+        // resolving it programmatically ~30ms after launch, which no polled UI
+        // could ever render.
+        const approval = resolvePreparedDelegationApproval({
+          autoApprove: body.autoApprove,
+          approvalManager: context.approvalManager,
+          runId,
+        });
+        if (approval.approved) {
+          emitRuntimeLog(session, `approval: run ${runId} auto-approved (autoApprove opt-in)`);
+        } else {
+          emitRuntimeLog(session, `approval: run ${runId} awaiting explicit approval before mutations (/approve or « valide tout »)`);
         }
         body._planReady?.resolve?.({ runId, planRevision: session.agentProjection?.planRevision ?? 0 });
       }
@@ -1182,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;
@@ -1244,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,6 +1,100 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { forwardRuntimeApproval } from './wiki-manager.js';
+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;
@@ -26,3 +120,39 @@ test('runtime approval bridge preserves the complete run-scoped grant', async ()
   assert.deepEqual(forwarded, request);
   assert.deepEqual(result, { approved: true });
 });
+
+test('prepared delegation waits for explicit approval by default', () => {
+  let calls = 0;
+  const result = resolvePreparedDelegationApproval({
+    runId: 'run-gated',
+    approvalManager: {
+      approve() {
+        calls += 1;
+      },
+    },
+  });
+
+  assert.equal(calls, 0);
+  assert.deepEqual(result, { approved: false, awaitingApproval: true });
+});
+
+test('prepared delegation only approves when autoApprove is explicitly true', () => {
+  let forwarded = null;
+  const result = resolvePreparedDelegationApproval({
+    autoApprove: true,
+    runId: 'run-headless',
+    approvalManager: {
+      approve(request) {
+        forwarded = request;
+        return { approved: true };
+      },
+    },
+  });
+
+  assert.deepEqual(forwarded, { scope: 'run', runId: 'run-headless' });
+  assert.deepEqual(result, {
+    approved: true,
+    awaitingApproval: false,
+    result: { approved: true },
+  });
+});