@dotdrelle/wiki-manager 0.12.0 → 0.12.7

package/src/runtime/recoveryManager.test.js

@@ -160,3 +160,76 @@ function recoverySession() {
     }],
   };
 }
+
+test('recoveryManager fails unresolvable-capability tasks and interrupts the run', async () => {
+  const { store, root, runId, taskId } = storeWithActiveTask();
+  const session = recoverySession();
+  // A registry that DOES know capabilities, but not the task's one: the plan
+  // came from a hallucinated capability (the 0.12.1 incident) — re-attaching
+  // it would recreate a forever-waiting queue on every boot.
+  session.agentRegistrySnapshot = [{
+    agentInstanceId: 'production-main',
+    serverName: 'production',
+    health: 'available',
+    description: {
+      agentType: 'production',
+      contractVersion: '1',
+      capabilities: [{ id: 'knowledge.pipeline', version: '1' }],
+    },
+  }];
+  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: '{}' }] };
+      },
+    });
+
+    assert.equal(result.ok, true);
+    assert.equal(result.recovered.length, 0);
+    assert.equal(result.rescheduled.length, 0);
+    assert.equal(result.interrupted.length, 1);
+    assert.match(result.interrupted[0].reason, /unresolvable capability: document\.build/);
+    assert.deepEqual(statusCalls, [], 'no agent_status poll for an unresolvable task');
+    assert.equal(store.listTasks({ runId })[0].status, 'failed');
+    // The run must not come back as a zombie on the next boot.
+    assert.deepEqual(store.listRecoverableRuns({ workspace: 'docs' }), []);
+  } finally {
+    store.close();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('recoveryManager keeps recovering when the registry has no capability information', async () => {
+  const { store, root, runId, taskId } = storeWithActiveTask();
+  const session = recoverySession(); // snapshot without capability lists
+  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: 'done',
+          result: { status: 'succeeded', outputRefs: [], metrics: {} },
+        }) }],
+      }),
+    });
+
+    assert.equal(result.recovered.length, 1, 'uninformative registry must not block recovery');
+    assert.equal(store.listTasks({ runId })[0].status, 'done');
+  } finally {
+    store.close();
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/src/runtime/runner.js

@@ -1,7 +1,7 @@
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
-import { sessionActivities, terminalFailures } from '../core/activity.js';
+import { isCancelledStatus, sessionActivities, terminalFailures } from '../core/activity.js';
 import { runAgenticLoop, throwIfAborted } from '../core/agentLoop.js';
-import { formatPlanStatus } from '../core/plan.js';
+import { formatPlanStatus, formatPlanStep } from '../core/plan.js';
 import { readyPlanTasks, sanitizePlanForExecution } from '../core/planPatch.js';
 import { createAssignmentManager } from '../orchestrator/assignmentManager.js';
 import { createAttemptManager } from '../orchestrator/attemptManager.js';
@@ -134,6 +134,19 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
           continue;
         }
       }
+      if (!trigger && isCancelledOnlyLoopResult(result)) {
+        dispatchAgentEvent(session, createAgentEvent('run_cancelled', {
+          origin: 'runtime',
+          runId,
+          payload: {
+            runId,
+            cancelled: true,
+            message: 'Runtime run cancelled by user.',
+          },
+        }));
+        emitRuntimeLog(session, 'runtime: run ended by user cancellation (no replan)');
+        return { ok: false, result, cancelled: true };
+      }
       dispatchAgentEvent(session, createAgentEvent('run_error', {
         origin: 'runtime',
         runId,
@@ -800,6 +813,7 @@ export async function replanRuntimeRun(session, input, trigger, {
         'Given the original objective, current plan, and failure reason, return only the remaining steps required.',
         'Do not include steps that are already done.',
         'Return only JSON with this exact shape: {"steps":["..."]}.',
+        'Each step MUST be a plain string, not an object.',
       ].join('\n'),
       tools: [],
       messages: [{ role: 'user', content: buildReplanPrompt(input, session, trigger) }],
@@ -825,10 +839,12 @@ export async function replanRuntimeRun(session, input, trigger, {
         steps: mergedSteps,
       },
     }));
-    if (hasMutatingReplanStep(steps)) {
-      session._runApprovalRequired = true;
-      session._runApprovalResolved = false;
-    }
+    // Every replan requires approval: deciding "is this step mutating?" with
+    // a verb regex was a safety judgement made by pattern-matching — a
+    // missed verb silently skipped the approval gate. Replans are rare
+    // (technical failures only) and re-executing work deserves a human OK.
+    session._runApprovalRequired = true;
+    session._runApprovalResolved = false;
     return { ok: true, steps };
   } catch (err) {
     return { ok: false, reason: err instanceof Error ? err.message : String(err) };
@@ -847,7 +863,12 @@ function replanTriggerFromLoopResult(result) {
     };
   }
   const failures = terminalFailures(result.completed ?? []);
-  const failure = failures[0];
+  const technical = failures.filter((failure) => !isCancelledStatus(failure.status));
+  const cancelled = failures.filter((failure) => isCancelledStatus(failure.status));
+  if (cancelled.length > 0 && technical.length === 0 && (result.failures ?? []).every(isCancelledTaskFailure)) {
+    return null;
+  }
+  const failure = technical[0];
   if (failure) {
     return {
       kind: 'activity_error',
@@ -859,7 +880,7 @@ function replanTriggerFromLoopResult(result) {
   // The parallel scheduler can fail a task before it ever produces an
   // _activity (e.g. a thrown error on the first turn) — that failure lives
   // in result.failures, not in any activity, so it must be checked too.
-  const taskFailure = (result.failures ?? [])[0];
+  const taskFailure = (result.failures ?? []).find((failure) => !isCancelledTaskFailure(failure));
   if (!taskFailure) return null;
   return {
     kind: 'task_error',
@@ -869,6 +890,25 @@ function replanTriggerFromLoopResult(result) {
   };
 }
 
+function isCancelledTaskFailure(failure) {
+  return failure?.cancelled === true
+    || failure?.result?.cancelled === true
+    || isCancelledStatus(failure?.status)
+    || isCancelledStatus(failure?.result?.status);
+}
+
+function isCancelledOnlyLoopResult(result) {
+  const failures = terminalFailures(result.completed ?? []);
+  const technicalActivities = failures.filter((failure) => !isCancelledStatus(failure.status));
+  const cancelledActivities = failures.filter((failure) => isCancelledStatus(failure.status));
+  const taskFailures = result.failures ?? [];
+  const technicalTasks = taskFailures.filter((failure) => !isCancelledTaskFailure(failure));
+  const cancelledTasks = taskFailures.filter(isCancelledTaskFailure);
+  return technicalActivities.length === 0
+    && technicalTasks.length === 0
+    && (cancelledActivities.length > 0 || cancelledTasks.length > 0);
+}
+
 function runtimeLoopErrorMessage(result) {
   if (result.timedOut) return 'Runtime agentic loop timed out.';
   if (result.maxTurns) return 'Runtime agentic loop reached max turns.';
@@ -912,15 +952,11 @@ function buildReplannedRunPrompt(input, trigger, steps) {
 function normalizeReplan(steps) {
   if (!Array.isArray(steps)) return [];
   return steps
-    .map((step) => String(step ?? '').trim())
+    .map((step) => formatPlanStep(step).trim())
     .filter(Boolean)
     .slice(0, 12);
 }
 
-function hasMutatingReplanStep(steps) {
-  return steps.some((step) => /\b(build|copy|ingest|import|export|polish|pipeline|write|create|delete|update|send|deploy|publish|generate|construire|copier|importer|exporter|publier|envoyer|supprimer|modifier|creer|générer|generer)\b/i.test(step));
-}
-
 function mergeReplanWithCompleted(plan, steps) {
   const completed = (plan ?? [])
     .filter((step) => step.status === 'done')

package/src/runtime/runner.test.js

@@ -259,6 +259,30 @@ test('replanRuntimeRun preserves completed outputs when replacing remaining work
   assert.deepEqual(session.headlessPlan[1].dependsOn, ['export']);
 });
 
+test('replanRuntimeRun normalizes object steps without leaking object strings', async () => {
+  const session = {
+    activities: {},
+    headlessPlan: [{ step: 1, id: 'done', description: 'Done', status: 'done' }],
+    llm: {
+      async completeWithTools({ system }) {
+        assert.match(system, /Each step MUST be a plain string, not an object\./);
+        return { content: '{"steps":["a",{"description":"b"},{"id":"c"},{},null]}' };
+      },
+    },
+  };
+
+  const result = await replanRuntimeRun(session, 'Build deliverable', {
+    kind: 'activity_error',
+    reason: 'Build failed.',
+  }, { runId: 'run-replan-object-steps', replansLeft: 1 });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.steps, ['a', 'b', 'c']);
+  assert.deepEqual(session.agentProjection.replans[0].plan, ['a', 'b', 'c']);
+  assert.deepEqual(session.headlessPlan.slice(1).map((step) => step.description), ['a', 'b', 'c']);
+  assert.equal(JSON.stringify(session.headlessPlan).includes('[object Object]'), false);
+});
+
 test('replanRuntimeRun requires runtime approval for mutating replanned work', async () => {
   const session = {
     activities: {},
@@ -370,6 +394,154 @@ test('runRuntimeAgenticWorkflow replans after terminal activity error', async ()
   }
 });
 
+test('runRuntimeAgenticWorkflow treats user-cancelled activity as terminal cancellation without replan', async () => {
+  const originalFetch = globalThis.fetch;
+  let pollAttempts = 0;
+  const events = [];
+  globalThis.fetch = async () => {
+    pollAttempts += 1;
+    return mcpActivityResponse({
+      id: 'job-cancelled',
+      source: 'production',
+      label: 'Production build',
+      status: 'cancelled',
+      terminal: true,
+    });
+  };
+  const session = {
+    mcp: {
+      production: {
+        status: 'connected',
+        url: 'http://127.0.0.1:3000/mcp/',
+        retry: { maxAttempts: 1, backoffMs: 0 },
+      },
+    },
+    activities: {},
+    headlessPlan: null,
+    llm: {
+      async completeWithTools() {
+        assert.fail('cancelled activity must not call evaluator or replanner');
+      },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+  const agent = {
+    async invoke({ session: turnSession }) {
+      dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+        payload: {
+          activity: runningPollableActivity('job-cancelled', 'Production build'),
+        },
+      }));
+      return { response: 'Started build.' };
+    },
+  };
+
+  try {
+    const result = await runRuntimeAgenticWorkflow(agent, session, 'Build workspace', {
+      runId: 'run-cancelled-activity',
+      timeoutMs: 1000,
+      maxTurns: 1,
+      maxReplans: 1,
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.cancelled, true);
+    assert.equal(pollAttempts, 1);
+    assert.equal(events.some((event) => event.type === 'run_replanned'), false);
+    assert.ok(events.some((event) => event.type === 'run_cancelled' && event.payload?.cancelled === true));
+    assert.equal(session.agentProjection.status, 'cancelled');
+    assert.match(session.agentProjection.logs.join('\n'), /run ended by user cancellation \(no replan\)/);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('runRuntimeAgenticWorkflow replans from failed activity when another activity is cancelled', async () => {
+  const originalFetch = globalThis.fetch;
+  const events = [];
+  const pollStatuses = new Map([
+    ['job-failed', {
+      id: 'job-failed',
+      source: 'production',
+      label: 'Production build',
+      status: 'failed',
+      terminal: true,
+      error: 'build failed',
+    }],
+    ['job-cancelled', {
+      id: 'job-cancelled',
+      source: 'production',
+      label: 'Production cleanup',
+      status: 'cancelled',
+      terminal: true,
+    }],
+  ]);
+  globalThis.fetch = async (_url, options = {}) => {
+    const body = JSON.parse(String(options.body ?? '{}'));
+    return mcpActivityResponse(pollStatuses.get(body.params?.arguments?.jobId));
+  };
+  const session = {
+    mcp: {
+      production: {
+        status: 'connected',
+        url: 'http://127.0.0.1:3000/mcp/',
+        retry: { maxAttempts: 1, backoffMs: 0 },
+      },
+    },
+    activities: {},
+    headlessPlan: null,
+    llm: {
+      async completeWithTools({ system }) {
+        if (/replanner/.test(system)) return { content: '{"steps":["Retry build"]}' };
+        return { content: '{"ok":true,"reason":"Build complete.","suggestedAction":null}' };
+      },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+  let turns = 0;
+  const agent = {
+    async invoke({ session: turnSession }) {
+      turns += 1;
+      if (turns === 1) {
+        dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+          payload: { activity: runningPollableActivity('job-failed', 'Production build') },
+        }));
+        dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+          payload: { activity: runningPollableActivity('job-cancelled', 'Production cleanup') },
+        }));
+        return { response: 'Started build.' };
+      }
+      const pending = turnSession.headlessPlan?.find((step) => step.status === 'pending');
+      if (pending) {
+        dispatchAgentEvent(turnSession, createAgentEvent('plan_step_updated', {
+          origin: 'tool',
+          payload: { taskId: pending.id, status: 'done' },
+        }));
+      }
+      return { response: 'Retry done.' };
+    },
+  };
+
+  try {
+    const result = await runRuntimeAgenticWorkflow(agent, session, 'Build workspace', {
+      runId: 'run-failed-and-cancelled',
+      timeoutMs: 1000,
+      maxTurns: 3,
+      maxReplans: 1,
+    });
+
+    assert.equal(result.ok, true);
+    assert.equal(turns, 2);
+    assert.equal(events.some((event) => event.type === 'run_cancelled'), false);
+    assert.ok(events.some((event) => event.type === 'run_replanned'));
+    assert.equal(session.agentProjection.replans[0].reason, 'Production build ended with failed: build failed');
+    assert.deepEqual(session.agentProjection.replans[0].plan, ['Retry build']);
+    assert.equal(session.agentProjection.status, 'done');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
 test('runRuntimeAgenticWorkflow stops after replan budget is exhausted', async () => {
   const session = {
     activities: {},
@@ -707,6 +879,30 @@ function productionAgent() {
   };
 }
 
+function runningPollableActivity(id, label) {
+  return {
+    id,
+    source: 'production',
+    label,
+    status: 'running',
+    terminal: false,
+    poll: { server: 'production', tool: 'production_job_status', args: { jobId: id }, intervalMs: 0 },
+  };
+}
+
+function mcpActivityResponse(activity) {
+  return {
+    ok: true,
+    status: 200,
+    headers: { get: () => null },
+    text: async () => JSON.stringify({
+      result: {
+        content: [{ type: 'text', text: JSON.stringify({ _activity: activity }) }],
+      },
+    }),
+  };
+}
+
 function toolResult(payload) {
   return { content: [{ type: 'text', text: JSON.stringify(payload) }] };
 }

package/src/runtime/server.js

@@ -5,6 +5,7 @@ import { activeCacertPath } from '../core/cacert.js';
 import { normalizePlanPatch, rebasePlanPatch } from '../core/planPatch.js';
 import { validateContractInDev } from '../contracts/schemas.js';
 import { runtimeTokenFromEnv } from './auth.js';
+import { controlMessage } from './controlMessages.js';
 
 export function startRuntimeServer({
   host = '127.0.0.1',
@@ -241,15 +242,19 @@ export function startRuntimeServer({
           }
           validateContractInDev('runRequest', { ...body, input });
           if (context.running) {
-            const item = enqueueControlRequest(context, input);
-            sendJson(response, 202, {
-              accepted: true,
-              queued: true,
-              kind: 'enqueue_run',
-              item,
-              ...controlStatus(context, store),
-              explanation: 'Request queued for a future run.',
+            // Blind enqueueing made every message typed during a run
+            // invisible until the run ended (serve UI symptom: "no result
+            // until the job finished or was stopped"). Classify instead:
+            // observe → immediate status explanation, cancel → abort,
+            // ambiguous action → explicit choices, explicit "later" intent
+            // (body.intent = 'enqueue') → enqueue as before.
+            const result = await handleControlMessage(context, store, input, {
+              intent: body.intent,
+              startNextControlRequest,
+              cancel,
+              approve,
             });
+            sendJson(response, result.statusCode, result.body);
             return;
           }
           const accepted = startRuntimeRun(context, body);
@@ -273,6 +278,16 @@ export function startRuntimeServer({
         sendJson(response, 202, { cancelled: true, workspace: context.workspace ?? workspace ?? null });
         return;
       }
+      if (request.method === 'POST' && url.pathname === '/kill') {
+        const body = await readJson(request);
+        const workspace = workspaceFromBody(body) ?? workspaceFromUrl(url);
+        const runId = url.searchParams.get('runId') ?? body.runId ?? null;
+        const context = await resolveContext({ workspace });
+        const result = await killRuntimeRuns(context, { workspace, runId });
+        publishState(context.workspace ?? workspace ?? null, context);
+        sendJson(response, 202, result);
+        return;
+      }
       if (request.method === 'POST' && url.pathname === '/shutdown') {
         const workspace = workspaceFromUrl(url);
         const context = await resolveContext({ workspace });
@@ -354,6 +369,23 @@ export function startRuntimeServer({
     return { body, workspace, context };
   }
 
+  async function killRuntimeRuns(context, { workspace = null, runId = null } = {}) {
+    const targetWorkspace = context?.workspace ?? workspace ?? null;
+    const targetRunId = runId ? String(runId) : null;
+    if (!targetRunId || targetRunId === context?.currentRunId) {
+      context?.currentAbortController?.abort();
+      await cancel?.(context);
+    }
+    const runs = typeof store.interruptRuns === 'function'
+      ? store.interruptRuns({ workspace: targetWorkspace, runId: targetRunId, reason: 'Runtime run killed by user.' })
+      : 0;
+    const tasks = typeof store.cancelActiveTasksForInterruptedRuns === 'function'
+      ? store.cancelActiveTasksForInterruptedRuns({ workspace: targetWorkspace, runId: targetRunId })
+      : 0;
+    const queued = cancelQueuedControlItems(context?.session, targetWorkspace);
+    return { killed: true, workspace: targetWorkspace, runId: targetRunId, runs, tasks, queued };
+  }
+
   function startRuntimeRun(context, body, { controlItemId = null } = {}) {
     const runId = randomUUID();
     const runWorkspace = context.workspace ?? body.workspace ?? null;
@@ -471,6 +503,34 @@ function controlQueueFor(session) {
   return Array.isArray(session?.controlQueue) ? session.controlQueue : [];
 }
 
+function cancelQueuedControlItems(session, workspace = null) {
+  const now = new Date().toISOString();
+  const counted = new Set();
+  let count = 0;
+  for (const queue of [controlQueueFor(session), session?.agentProjection?.controlQueue].filter(Array.isArray)) {
+    for (const item of queue) {
+      if (item.status !== 'queued') continue;
+      if (workspace && item.workspace && item.workspace !== workspace) continue;
+      item.status = 'cancelled';
+      item.finishedAt = now;
+      item.updatedAt = now;
+      const id = item.id ?? item.runId ?? `${item.input}:${item.createdAt}`;
+      if (!counted.has(id)) {
+        counted.add(id);
+        if (session) {
+          dispatchAgentEvent(session, createAgentEvent('control_cancelled', {
+            origin: 'runtime',
+            workspace: item.workspace ?? workspace ?? null,
+            payload: { id, finishedAt: now },
+          }));
+        }
+        count += 1;
+      }
+    }
+  }
+  return count;
+}
+
 function readOnlyControlResponse(kind, classification, status, explanation, { accepted = true, extra = {} } = {}) {
   return {
     statusCode: 200,
@@ -522,7 +582,7 @@ async function handleControlMessage(context, store, input, { intent = null, star
         classification,
         proposal,
         ...controlStatus(context, store),
-        explanation: 'Plan patch proposed. Approve it explicitly to apply it to the active plan.',
+        explanation: controlMessage(context?.session, 'plan_patch_proposed'),
       },
     };
   }
@@ -540,12 +600,12 @@ async function handleControlMessage(context, store, input, { intent = null, star
         classification,
         item,
         ...controlStatus(context, store),
-        explanation: 'Request queued for a future run.',
+        explanation: controlMessage(context?.session, 'queued_for_future_run'),
       },
     };
   }
   if (classification.kind === 'ambiguous') {
-    return readOnlyControlResponse('ambiguous', classification, status, 'The runtime cannot safely classify this message.', {
+    return readOnlyControlResponse('ambiguous', classification, status, controlMessage(context?.session, 'ambiguous_control'), {
       accepted: false,
       extra: {
         choices: [
@@ -557,8 +617,8 @@ async function handleControlMessage(context, store, input, { intent = null, star
     });
   }
   return readOnlyControlResponse('converse', classification, status, status.running
-    ? 'Runtime run is still active. This message was treated as conversation and did not create a queued run.'
-    : 'Runtime is idle. This message was treated as conversation and did not create a run.');
+    ? controlMessage(context?.session, 'converse_while_running')
+    : controlMessage(context?.session, 'converse_while_idle'));
 }
 
 function enqueueControlRequest(context, input) {