@dotdrelle/wiki-manager 0.11.10 → 0.12.1

package/src/runtime/recoveryManager.test.js

@@ -0,0 +1,162 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { createAgentEvent } from '../core/agentEvents.js';
+import { openRuntimeStore } from './store.js';
+import { recoverActiveRuns } from './recoveryManager.js';
+
+test('recoveryManager attaches a terminal active job through agent_status', async () => {
+  const { store, root, runId, taskId } = storeWithActiveTask();
+  const session = recoverySession();
+  store.hydrateSession(session, { workspace: 'docs' });
+  const statusCalls = [];
+
+  try {
+    const result = await recoverActiveRuns({
+      store,
+      session,
+      workspace: 'docs',
+      callTool: async (_mcp, serverName, toolName, args) => {
+        statusCalls.push({ serverName, toolName, args });
+        return {
+          content: [{ type: 'text', text: JSON.stringify({
+            jobId: args.jobId,
+            taskId,
+            status: 'done',
+            result: {
+              status: 'succeeded',
+              outputRefs: [{ type: 'file', ref: 'deliverables/a.md' }],
+              metrics: { durationMs: 12 },
+            },
+          }) }],
+        };
+      },
+    });
+
+    assert.equal(result.ok, true);
+    assert.deepEqual(statusCalls, [{ serverName: 'production', toolName: 'agent_status', args: { jobId: 'job-1' } }]);
+    assert.equal(result.recovered[0].taskId, taskId);
+    assert.equal(store.listTasks({ runId })[0].status, 'done');
+    assert.equal(store.getTaskResult({ taskId }).status, 'succeeded');
+    assert.deepEqual(store.getTaskResult({ taskId }).outputRefs, [{ type: 'file', ref: 'deliverables/a.md' }]);
+  } finally {
+    store.close();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('recoveryManager requeues an active job by idempotencyKey when status is still running', async () => {
+  const { store, root, runId, taskId } = storeWithActiveTask();
+  const session = recoverySession();
+  store.hydrateSession(session, { workspace: 'docs' });
+
+  try {
+    const result = await recoverActiveRuns({
+      store,
+      session,
+      workspace: 'docs',
+      callTool: async (_mcp, _serverName, _toolName, args) => ({
+        content: [{ type: 'text', text: JSON.stringify({
+          jobId: args.jobId,
+          taskId,
+          status: 'running',
+          progress: { percent: 50 },
+        }) }],
+      }),
+    });
+
+    assert.equal(result.ok, true);
+    assert.equal(result.rescheduled[0].idempotencyKey, 'idem-a');
+    assert.equal(store.listTasks({ runId })[0].status, 'pending');
+    assert.ok(session.agentEvents.some((event) => event.type === 'plan_step_updated'
+      && event.payload?.recovery?.idempotencyKey === 'idem-a'));
+  } finally {
+    store.close();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+function storeWithActiveTask() {
+  const root = mkdtempSync(join(tmpdir(), 'wiki-manager-recovery-'));
+  const stateDir = join(root, '.wiki-manager');
+  const store = openRuntimeStore({ stateDir });
+  const runId = 'run-recovery';
+  const taskId = 'run-recovery:build-a';
+  const attemptId = `${taskId}:attempt-1`;
+  for (const event of [
+    createAgentEvent('run_started', {
+      origin: 'runtime',
+      runId,
+      workspace: 'docs',
+      payload: { input: 'build docs', workspace: 'docs' },
+    }),
+    createAgentEvent('task.created', {
+      origin: 'plan_integrator',
+      runId,
+      taskId,
+      workspace: 'docs',
+      payload: { runId, task: plannedTask(taskId) },
+    }),
+    createAgentEvent('task.assigned', {
+      origin: 'assignment_manager',
+      runId,
+      taskId,
+      workspace: 'docs',
+      payload: {
+        runId,
+        taskId,
+        attemptId,
+        assignment: { attemptId, agentInstanceId: 'production-main', agentId: 'production' },
+      },
+    }),
+    createAgentEvent('task.started', {
+      origin: 'dispatcher',
+      runId,
+      taskId,
+      workspace: 'docs',
+      payload: { runId, taskId, attemptId, jobId: 'job-1', startedAt: '2026-07-07T10:00:00.000Z' },
+    }),
+  ]) {
+    store.persistEvent(event);
+  }
+  return { store, root, runId, taskId };
+}
+
+function plannedTask(id) {
+  return {
+    id,
+    localId: 'build-a',
+    label: 'Build A',
+    description: 'Build A',
+    requiredCapability: 'document.build',
+    operation: 'build',
+    arguments: { templates: ['a.md'] },
+    groupId: null,
+    dependsOn: [],
+    inputRefs: [],
+    expectedOutputRefs: [{ type: 'file', ref: 'deliverables/a.md' }],
+    locks: ['workspace-write'],
+    requiresApproval: false,
+    idempotencyKey: 'idem-a',
+    progressWeight: 1,
+    status: 'running',
+  };
+}
+
+function recoverySession() {
+  return {
+    workspace: 'docs',
+    activities: {},
+    mcp: {
+      production: { tools: [{ name: 'agent_status' }] },
+    },
+    agentRegistrySnapshot: [{
+      agentInstanceId: 'production-main',
+      serverName: 'production',
+      description: { agentType: 'production', contractVersion: '1' },
+    }],
+  };
+}

package/src/runtime/runner.e2e.test.js

@@ -12,32 +12,118 @@ const MAX_PARALLEL_TO_SEQUENTIAL_RATIO = 0.65;
 
 function buildTwoTemplatePlan() {
   return [
-    { step: 1, id: 'template-a', description: 'Build template A', status: 'pending', dependsOn: [] },
-    { step: 2, id: 'template-b', description: 'Build template B', status: 'pending', dependsOn: [] },
+    plannedBuildTask(1, 'template-a'),
+    plannedBuildTask(2, 'template-b'),
   ];
 }
 
-function latencyAgent() {
-  return {
-    async invoke() {
-      await new Promise((resolve) => setTimeout(resolve, SIMULATED_BUILD_LATENCY_MS));
-      return { response: 'done' };
+async function timedRun(concurrency, runId) {
+  const jobs = new Map();
+  const session = {
+    workspace: 'demo-workspace',
+    activities: {},
+    headlessPlan: buildTwoTemplatePlan(),
+    mcp: {
+      production: {
+        status: 'connected',
+        tools: [{ name: 'agent_execute' }, { name: 'agent_status' }, { name: 'agent_cancel' }],
+      },
     },
+    agentRegistrySnapshot: [productionAgent()],
+    wikircConfig: { capabilityRouting: {} },
+  };
+  const callTool = async (_mcp, _serverName, toolName, args) => {
+    if (toolName === 'agent_execute') {
+      const jobId = `job-${args.taskId}`;
+      jobs.set(jobId, { jobId, taskId: args.taskId, startedAt: Date.now() });
+      return toolResult({ accepted: true, jobId, status: 'queued' });
+    }
+    if (toolName === 'agent_status') {
+      const job = jobs.get(args.jobId);
+      const done = Date.now() - job.startedAt >= SIMULATED_BUILD_LATENCY_MS;
+      return toolResult({
+        jobId: job.jobId,
+        taskId: job.taskId,
+        operation: 'build',
+        status: done ? 'done' : 'running',
+        progress: { percent: done ? 100 : 50 },
+        ...(done ? { result: { status: 'succeeded', outputRefs: [], metrics: { durationMs: SIMULATED_BUILD_LATENCY_MS } } } : {}),
+      });
+    }
+    if (toolName === 'agent_cancel') return toolResult({ ok: true });
+    throw new Error(`unexpected tool: ${toolName}`);
   };
-}
-
-async function timedRun(concurrency, runId) {
-  const session = { activities: {}, headlessPlan: buildTwoTemplatePlan() };
   const startedAt = Date.now();
-  const result = await runRuntimeParallelPlan(latencyAgent(), session, 'Build 2 templates', {
+  const result = await runRuntimeParallelPlan({ invoke: async () => assert.fail('child Donna loop must not run') }, session, 'Build 2 templates', {
     runId,
     timeoutMs: 10_000,
     maxTurns: 1,
     concurrency,
+    callTool,
+    dispatcherPollIntervalMs: 5,
   });
   return { result, durationMs: Date.now() - startedAt };
 }
 
+function plannedBuildTask(step, id) {
+  return {
+    step,
+    id,
+    label: `Build ${id}`,
+    description: `Build ${id}`,
+    status: 'pending',
+    dependsOn: [],
+    requiredCapability: 'document.build',
+    operation: 'build',
+    arguments: { templates: [`${id}.md`] },
+    parallelizable: true,
+    inputRefs: [],
+    expectedOutputRefs: [],
+    locks: [],
+    requiresApproval: false,
+    idempotencyKey: 'test-idempotency-key',
+    progressWeight: 1,
+    outputRefs: [],
+  };
+}
+
+function productionAgent() {
+  return {
+    serverName: 'production',
+    agentInstanceId: 'production-main',
+    health: 'available',
+    description: {
+      contractVersion: '1',
+      agentType: 'production',
+      agentInstanceId: 'production-main',
+      displayName: 'Production',
+      capabilities: [{
+        id: 'document.build',
+        version: '1',
+        description: 'Build documents',
+        inputSchema: { type: 'object', additionalProperties: true },
+        outputSchema: { type: 'object', additionalProperties: true },
+        supportedOperations: ['build'],
+      }],
+      orchestration: {
+        canPlan: true,
+        canExpandPlan: false,
+        canExecute: true,
+        canCancel: true,
+        canResume: false,
+        supportsIdempotency: false,
+        supportsParallelWorkers: true,
+      },
+      limits: { recommendedConcurrency: 2, maxConcurrency: 2, maxTaskDurationMs: 10_000 },
+      health: { status: 'available' },
+    },
+  };
+}
+
+function toolResult(payload) {
+  return { content: [{ type: 'text', text: JSON.stringify(payload) }] };
+}
+
 test('multi-agent scheduler beats sequential on 2 independent build tasks by the required margin (plan 0.11.4 §3 guard)', async () => {
   const { result: sequentialResult, durationMs: sequentialDurationMs } = await timedRun(1, 'e2e-accel-sequential');
   const { result: parallelResult, durationMs: parallelDurationMs } = await timedRun(2, 'e2e-accel-parallel');