@dotdrelle/wiki-manager 0.11.9 → 0.12.0

package/src/runtime/donna-contract.test.js

@@ -1,7 +1,8 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
+import { createAgentGraph } from '../agent/graph.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
-import { runRuntimeAgenticWorkflow } from './runner.js';
+import { runRuntimeAgenticWorkflow, runRuntimeParallelPlan } from './runner.js';
 import { startRuntimeServer } from './server.js';
 
 // Executable version of plan-0.11.5-hotfix-final.md §3 ("La recette — le seul
@@ -140,6 +141,123 @@ test('Recipe #3 — "où en est le dernier build ?" reads status, starts no new
   assert.equal(types.includes('plan_set'), false);
 });
 
+test('CME setup and source configuration stay outside export orchestration', async () => {
+  const originalFetch = globalThis.fetch;
+  const calledTools = [];
+  globalThis.fetch = async (_url, options = {}) => {
+    const body = JSON.parse(String(options.body ?? '{}'));
+    calledTools.push(body.params?.name);
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      text: async () => JSON.stringify({ result: { content: [{ type: 'text', text: '{"ok":true}' }] } }),
+    };
+  };
+  let turn = 0;
+  const session = baseSession({
+    commands: ['status'],
+    workspace: 'demo-workspace',
+    mcp: {
+      cme: {
+        status: 'connected',
+        url: 'http://127.0.0.1:3010/mcp/',
+        tools: [
+          { name: 'cme_setup', inputSchema: { type: 'object', additionalProperties: true } },
+          { name: 'cme_source_add', inputSchema: { type: 'object', additionalProperties: true } },
+          { name: 'cme_export_run', inputSchema: { type: 'object', additionalProperties: true } },
+        ],
+      },
+    },
+    llm: {
+      async completeWithTools() {
+        turn += 1;
+        if (turn === 1) {
+          return {
+            content: null,
+            message: { role: 'assistant', content: null },
+            tool_calls: [
+              {
+                id: 'setup',
+                type: 'function',
+                function: {
+                  name: 'cme__cme_setup',
+                  arguments: JSON.stringify({ workspace: 'demo-workspace', base_url: 'https://confluence.example', username: 'user@example.com', pat: 'token' }),
+                },
+              },
+              {
+                id: 'source',
+                type: 'function',
+                function: {
+                  name: 'cme__cme_source_add',
+                  arguments: JSON.stringify({ workspace: 'demo-workspace', name: 'docs', base_url: 'https://confluence.example', space: 'DOC' }),
+                },
+              },
+            ],
+          };
+        }
+        return {
+          content: 'CME est configuré.',
+          message: { role: 'assistant', content: 'CME est configuré.' },
+          tool_calls: null,
+        };
+      },
+    },
+  });
+
+  try {
+    const result = await runRuntimeAgenticWorkflow(createAgentGraph(), session, 'configure cme', {
+      runId: 'cme-config',
+      timeoutMs: 1000,
+      maxTurns: 2,
+      evaluate: false,
+    });
+
+    assert.equal(result.ok, true);
+    assert.deepEqual(calledTools, ['cme_setup', 'cme_source_add']);
+    assert.equal(calledTools.includes('cme_export_run'), false);
+    assert.equal((session.headlessPlan ?? []).some((step) => step.requiredCapability === 'external-source.export'), false);
+    assert.equal((session.headlessPlan ?? []).some((step) => step.operation === 'export'), false);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('CME export is dispatched only from an approved DAG task', async () => {
+  let executeCalls = 0;
+  const session = baseSession({
+    workspace: 'demo-workspace',
+    mcp: {
+      cme: {
+        status: 'connected',
+        tools: [{ name: 'agent_execute' }, { name: 'agent_status' }, { name: 'agent_cancel' }],
+      },
+    },
+    agentRegistrySnapshot: [cmeAgent()],
+    wikircConfig: { capabilityRouting: {} },
+    approvals: [],
+    headlessPlan: [plannedCmeExportTask({ status: 'waiting_approval' })],
+  });
+  const callTool = async (_mcp, _serverName, toolName) => {
+    if (toolName === 'agent_execute') executeCalls += 1;
+    throw new Error(`unexpected tool: ${toolName}`);
+  };
+
+  const result = await runRuntimeParallelPlan({ invoke: async () => assert.fail('no child loop') }, session, 'export cme', {
+    runId: 'cme-export-approval',
+    timeoutMs: 100,
+    maxTurns: 1,
+    callTool,
+    dispatcherPollIntervalMs: 1,
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.stalled, true);
+  assert.equal(result.reason, 'awaiting_approval');
+  assert.equal(executeCalls, 0);
+  assert.equal(session.headlessPlan[0].status, 'waiting_approval');
+});
+
 function buildSingleTaskAgent({ taskId, description, finalResponse }) {
   let turn = 0;
   return {
@@ -209,41 +327,65 @@ test('Recipe #5 — "construis le livrable X": plan posed, job runs, progress, d
 });
 
 function buildTwoParallelTasksAgent() {
-  const started = [];
-  const release = {};
   let parentTurnDone = false;
   return {
-    started,
-    release,
-    async invoke({ input, session: turnSession }) {
-      const taskMatch = input.match(/Task id: (\w+)/);
-      if (!taskMatch) {
-        if (!parentTurnDone) {
-          parentTurnDone = true;
-          dispatchAgentEvent(turnSession, createAgentEvent('plan_set', {
-            origin: 'tool',
-            payload: {
-              steps: [
-                { step: 1, id: 'x', description: 'Construire X', status: 'pending', dependsOn: [] },
-                { step: 2, id: 'y', description: 'Construire Y', status: 'pending', dependsOn: [] },
-              ],
-            },
-          }));
-          return { response: 'Je construis X et Y en parallèle.' };
-        }
-        return { response: 'X et Y sont construits.' };
+    async invoke({ session: turnSession }) {
+      if (!parentTurnDone) {
+        parentTurnDone = true;
+        dispatchAgentEvent(turnSession, createAgentEvent('plan_set', {
+          origin: 'tool',
+          payload: {
+            steps: [
+              plannedDoctorTask('x', []),
+              plannedDoctorTask('y', []),
+            ],
+          },
+        }));
+        return { response: 'Je construis X et Y en parallèle.' };
       }
-      const id = taskMatch[1];
-      started.push(id);
-      await new Promise((resolve) => { release[id] = resolve; });
-      return { response: `${id} construit.` };
+      assert.fail('contractual tasks must be dispatched through agent tools, not child Donna turns');
     },
   };
 }
 
 test('Recipe #6 — "construis X et Y": two tasks run in parallel, converge, done', async () => {
-  const session = baseSession();
+  const completed = new Set();
+  const jobs = new Map();
+  const executeOrder = [];
+  const session = baseSession({
+    workspace: 'demo-workspace',
+    mcp: {
+      production: {
+        status: 'connected',
+        tools: [{ name: 'agent_execute' }, { name: 'agent_status' }, { name: 'agent_cancel' }],
+      },
+    },
+    agentRegistrySnapshot: [productionAgent()],
+    wikircConfig: { capabilityRouting: {} },
+  });
   const agent = buildTwoParallelTasksAgent();
+  const callTool = async (_mcp, _serverName, toolName, args) => {
+    if (toolName === 'agent_execute') {
+      executeOrder.push(args.taskId);
+      const jobId = `job-${args.taskId}`;
+      jobs.set(jobId, { jobId, taskId: args.taskId });
+      return toolResult({ accepted: true, jobId, status: 'queued' });
+    }
+    if (toolName === 'agent_status') {
+      const job = jobs.get(args.jobId);
+      const done = completed.has(job.taskId);
+      return toolResult({
+        jobId: job.jobId,
+        taskId: job.taskId,
+        operation: 'doctor',
+        status: done ? 'done' : 'running',
+        progress: { percent: done ? 100 : 50 },
+        ...(done ? { result: { status: 'succeeded', outputRefs: [], metrics: { durationMs: 1 } } } : {}),
+      });
+    }
+    if (toolName === 'agent_cancel') return toolResult({ ok: true });
+    throw new Error(`unexpected tool: ${toolName}`);
+  };
 
   const running = runRuntimeAgenticWorkflow(agent, session, 'construis X et Y', {
     runId: 'recipe-6',
@@ -251,15 +393,17 @@ test('Recipe #6 — "construis X et Y": two tasks run in parallel, converge, don
     maxTurns: 3,
     maxReplans: 1,
     evaluate: false,
+    callTool,
+    dispatcherPollIntervalMs: 1,
   });
 
-  await waitFor(() => agent.started.includes('x') && agent.started.includes('y'));
+  await waitFor(() => executeOrder.includes('x') && executeOrder.includes('y'));
   assert.deepEqual(
     session.headlessPlan.filter((step) => ['x', 'y'].includes(step.id)).map((step) => step.status),
     ['running', 'running'],
   );
-  agent.release.x();
-  agent.release.y();
+  completed.add('x');
+  completed.add('y');
 
   const result = await running;
 
@@ -267,6 +411,125 @@ test('Recipe #6 — "construis X et Y": two tasks run in parallel, converge, don
   assert.deepEqual(session.headlessPlan.map((step) => step.status), ['done', 'done']);
 });
 
+function plannedDoctorTask(id, dependsOn) {
+  return {
+    step: id === 'x' ? 1 : 2,
+    id,
+    label: `Construire ${id.toUpperCase()}`,
+    description: `Construire ${id.toUpperCase()}`,
+    status: 'pending',
+    dependsOn,
+    requiredCapability: 'workspace.diagnose',
+    operation: 'doctor',
+    arguments: {},
+    parallelizable: true,
+    inputRefs: [],
+    expectedOutputRefs: [],
+    locks: [],
+    requiresApproval: false,
+    idempotencyKey: null,
+    progressWeight: 1,
+    outputRefs: [],
+  };
+}
+
+function plannedCmeExportTask(overrides = {}) {
+  return {
+    step: 1,
+    id: 'cme-export',
+    label: 'Export CME',
+    description: 'Export CME',
+    status: 'pending',
+    dependsOn: [],
+    requiredCapability: 'external-source.export',
+    operation: 'export',
+    arguments: { source_name: 'docs' },
+    parallelizable: false,
+    inputRefs: [],
+    expectedOutputRefs: [{ type: 'directory', ref: 'raw/untracked' }],
+    locks: ['external-source:docs'],
+    requiresApproval: true,
+    approvalClass: 'external-source',
+    idempotencyKey: 'idem-cme-export',
+    progressWeight: 1,
+    outputRefs: [],
+    ...overrides,
+  };
+}
+
+function cmeAgent() {
+  return {
+    serverName: 'cme',
+    agentInstanceId: 'cme-main',
+    health: 'available',
+    description: {
+      contractVersion: '1',
+      agentType: 'cme',
+      agentInstanceId: 'cme-main',
+      displayName: 'CME',
+      capabilities: [{
+        id: 'external-source.export',
+        version: '1',
+        description: 'Export external source',
+        inputSchema: { type: 'object', additionalProperties: true },
+        outputSchema: { type: 'object', additionalProperties: true },
+        supportedOperations: ['export'],
+        mutationClass: 'external-source',
+        defaultRequiresApproval: true,
+      }],
+      orchestration: {
+        canPlan: false,
+        canExpandPlan: false,
+        canExecute: true,
+        canCancel: true,
+        canResume: false,
+        singleTaskOnly: true,
+        supportsIdempotency: true,
+        supportsParallelWorkers: false,
+      },
+      limits: { recommendedConcurrency: 1, maxConcurrency: 1, maxTaskDurationMs: 2000 },
+      health: { status: 'available' },
+    },
+  };
+}
+
+function productionAgent() {
+  return {
+    serverName: 'production',
+    agentInstanceId: 'production-main',
+    health: 'available',
+    description: {
+      contractVersion: '1',
+      agentType: 'production',
+      agentInstanceId: 'production-main',
+      displayName: 'Production',
+      capabilities: [{
+        id: 'workspace.diagnose',
+        version: '1',
+        description: 'Diagnose workspace',
+        inputSchema: { type: 'object', additionalProperties: true },
+        outputSchema: { type: 'object', additionalProperties: true },
+        supportedOperations: ['doctor'],
+      }],
+      orchestration: {
+        canPlan: true,
+        canExpandPlan: false,
+        canExecute: true,
+        canCancel: true,
+        canResume: false,
+        supportsIdempotency: false,
+        supportsParallelWorkers: true,
+      },
+      limits: { recommendedConcurrency: 2, maxConcurrency: 2, maxTaskDurationMs: 2000 },
+      health: { status: 'available' },
+    },
+  };
+}
+
+function toolResult(payload) {
+  return { content: [{ type: 'text', text: JSON.stringify(payload) }] };
+}
+
 test('Recipe #7 — "où en es-tu ?" during an active run: status in conversation, run continues, no new run', async (t) => {
   const session = { workspace: 'juno', controlQueue: [] };
   let runCount = 0;

package/src/runtime/recoveryManager.js

@@ -0,0 +1,176 @@
+import { parseJsonText } from '../core/activity.js';
+import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { formatMcpToolResult, callMcpTool as defaultCallMcpTool } from '../core/mcp.js';
+import { accept as acceptResult } from '../orchestrator/resultAggregator.js';
+
+const ACTIVE_TASK_STATUSES = new Set(['running', 'queued', 'starting', 'assigned']);
+const TERMINAL_STATUSES = new Set(['done', 'failed', 'cancelled', 'canceled', 'completed', 'complete', 'success', 'succeeded']);
+
+export async function recoverActiveRuns({
+  store,
+  session,
+  workspace = null,
+  callTool = defaultCallMcpTool,
+  resultAggregator = acceptResult,
+} = {}) {
+  if (!store) throw new Error('recoveryManager requires store.');
+  if (!session) throw new Error('recoveryManager requires session.');
+  const runs = store.listRecoverableRuns?.({ workspace }) ?? [];
+  const recovered = [];
+  const rescheduled = [];
+  const interrupted = [];
+  const errors = [];
+
+  for (const run of runs) {
+    const tasks = store.listTasks?.({ runId: run.id }) ?? [];
+    const activeTasks = tasks.filter((task) => ACTIVE_TASK_STATUSES.has(String(task.status ?? '').toLowerCase()));
+    for (const task of activeTasks) {
+      try {
+        const outcome = await recoverTask({ store, session, run, task, callTool, resultAggregator });
+        if (outcome?.status === 'recovered') recovered.push(outcome);
+        else if (outcome?.status === 'rescheduled') rescheduled.push(outcome);
+        else if (outcome?.status === 'interrupted') interrupted.push(outcome);
+      } catch (error) {
+        errors.push({ runId: run.id, taskId: task.id, error: error instanceof Error ? error.message : String(error) });
+      }
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    recovered,
+    rescheduled,
+    interrupted,
+    errors,
+  };
+}
+
+async function recoverTask({ store, session, run, task, callTool, resultAggregator }) {
+  const attempt = latestAttempt(store.listTaskAttempts?.({ taskId: task.id }) ?? []);
+  const assignment = latestAssignment(store.listTaskAssignments?.({ taskId: task.id }) ?? [], attempt?.attemptId);
+  if (!attempt?.jobId || !assignment?.agentInstanceId) {
+    return interruptTask({ store, session, run, task, reason: 'missing attempt job or assignment' });
+  }
+
+  const agent = agentFor(session, assignment.agentInstanceId);
+  const serverName = agent?.serverName ?? assignment.agentId ?? assignment.agentInstanceId;
+  const statusTool = toolNameFor(session, serverName, 'agent_status');
+  const status = parseToolPayload(await callTool(session.mcp, serverName, statusTool, { jobId: attempt.jobId }));
+
+  if (isTerminal(status?.status ?? status?.result?.status)) {
+    const result = taskResultFromStatus(task, assignment, attempt.jobId, status, attempt);
+    await resultAggregator(result, {
+      session,
+      runId: run.id,
+      task,
+      assignment: {
+        agentInstanceId: assignment.agentInstanceId,
+        serverName,
+        agent,
+      },
+      store,
+      registry: session.capabilityRegistry ?? null,
+      workspaceConfig: session.wikircConfig ?? session.wikirc?.config ?? {},
+      callTool,
+    });
+    return { status: 'recovered', runId: run.id, taskId: task.id, jobId: attempt.jobId };
+  }
+
+  if (task.idempotencyKey) {
+    dispatch(session, store, 'plan_step_updated', {
+      origin: 'recovery_manager',
+      runId: run.id,
+      taskId: task.id,
+        workspace: run.workspace ?? workspaceFromSession(session),
+      payload: {
+        taskId: task.id,
+        status: 'pending',
+        recovery: {
+          reason: 'active_job_requeued_by_idempotency',
+          jobId: attempt.jobId,
+          idempotencyKey: task.idempotencyKey,
+          agentInstanceId: assignment.agentInstanceId,
+        },
+      },
+    });
+    return { status: 'rescheduled', runId: run.id, taskId: task.id, jobId: attempt.jobId, idempotencyKey: task.idempotencyKey };
+  }
+
+  return interruptTask({ store, session, run, task, reason: 'active job is non-terminal and task has no idempotencyKey' });
+}
+
+function interruptTask({ store, session, run, task, reason }) {
+  dispatch(session, store, 'runtime_log', {
+    origin: 'recovery_manager',
+    runId: run.id,
+    taskId: task.id,
+    workspace: run.workspace ?? workspaceFromSession(session),
+    payload: { message: `recovery: ${task.id} interrupted (${reason})` },
+  });
+  return { status: 'interrupted', runId: run.id, taskId: task.id, reason };
+}
+
+function latestAttempt(attempts) {
+  return [...attempts].sort((a, b) => String(b.startedAt ?? b.finishedAt ?? b.attemptId).localeCompare(String(a.startedAt ?? a.finishedAt ?? a.attemptId)))[0] ?? null;
+}
+
+function latestAssignment(assignments, attemptId) {
+  if (attemptId) {
+    const matched = assignments.find((assignment) => assignment.attemptId === attemptId);
+    if (matched) return matched;
+  }
+  return [...assignments].sort((a, b) => String(b.assignedAt ?? b.attemptId).localeCompare(String(a.assignedAt ?? a.attemptId)))[0] ?? null;
+}
+
+function isTerminal(status) {
+  return TERMINAL_STATUSES.has(String(status ?? '').toLowerCase());
+}
+
+function parseToolPayload(result) {
+  if (result && typeof result === 'object' && !Array.isArray(result) && !Array.isArray(result.content)) return result;
+  return parseJsonText(formatMcpToolResult(result)) ?? {};
+}
+
+function taskResultFromStatus(task, assignment, jobId, statusPayload, attempt) {
+  const result = statusPayload?.result ?? {};
+  const status = String(result.status ?? statusPayload?.status ?? '').toLowerCase();
+  const ok = ['succeeded', 'success', 'done', 'complete', 'completed'].includes(status);
+  return {
+    ok,
+    taskId: task.id,
+    attemptId: statusPayload?.attemptId ?? attempt?.attemptId ?? null,
+    jobId,
+    agentInstanceId: assignment.agentInstanceId,
+    status: result.status ?? statusPayload?.status,
+    outputRefs: Array.isArray(result.outputRefs) ? result.outputRefs : [],
+    metrics: result.metrics ?? {},
+    error: result.error ?? null,
+    rawStatus: statusPayload,
+  };
+}
+
+function agentFor(session, agentInstanceId) {
+  return [
+    ...(session.agentRegistrySnapshot ?? []),
+    ...(session.agents ?? []),
+  ].find((agent) => agent?.agentInstanceId === agentInstanceId) ?? null;
+}
+
+function toolNameFor(session, serverName, baseName) {
+  const tools = session.mcp?.[serverName]?.tools ?? [];
+  const names = tools.map((tool) => String(tool.name ?? '')).filter(Boolean);
+  return names.find((name) => name === baseName)
+    ?? names.find((name) => name === `${serverName}__${baseName}`)
+    ?? names.find((name) => name.endsWith(`__${baseName}`))
+    ?? baseName;
+}
+
+function dispatch(session, store, type, event) {
+  const dispatched = dispatchAgentEvent(session, createAgentEvent(type, event));
+  store?.persistEvent?.(dispatched);
+  return dispatched;
+}
+
+function workspaceFromSession(session) {
+  return session.workspace ?? session._currentRunIdentity?.workspace ?? null;
+}