@dotdrelle/wiki-manager 0.12.1 → 0.12.8

package/src/runtime/server.test.js

@@ -224,15 +224,18 @@ test('runtime server accepts only one active run', async (t) => {
       fetch(url, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ input: 'second' }),
+        // Messages during an active run are now CLASSIFIED (observe answers
+        // immediately, cancel aborts…) — enqueueing a future run is the
+        // explicit intent.
+        body: JSON.stringify({ input: 'second', intent: 'enqueue' }),
       }),
     ]);
 
     assert.deepEqual([first.status, second.status], [202, 202]);
     const bodies = [await first.json(), await second.json()];
-    const acceptedRun = bodies.find((body) => body.accepted && !body.queued);
-    const queuedRun = bodies.find((body) => body.queued);
-    assert.equal(queuedRun.kind, 'enqueue_run');
+    const acceptedRun = bodies.find((body) => body.runId && body.accepted);
+    const queuedRun = bodies.find((body) => body.kind === 'enqueue_run');
+    assert.equal(queuedRun.accepted, true);
     assert.equal(acceptedRun.accepted, true);
     assert.match(acceptedRun.runId, /^[0-9a-f-]{36}$/);
     assert.equal(runCount, 1);
@@ -287,6 +290,158 @@ test('runtime server returns the accepted run id and passes it to the runner', a
   }
 });
 
+test('runtime server kill aborts active run and interrupts workspace work', async (t) => {
+  let abortSeen = false;
+  let cancelCalled = false;
+  let interruptArgs = null;
+  let taskCancelArgs = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'running' }),
+        listEvents: () => [],
+        interruptRuns: (args) => {
+          interruptArgs = args;
+          return 1;
+        },
+        cancelActiveTasksForInterruptedRuns: (args) => {
+          taskCancelArgs = args;
+          return 3;
+        },
+      },
+      session: { controlQueue: [{ id: 'control-1', workspace: 'docs', status: 'queued' }] },
+      run: async (_context, _body, { signal }) => {
+        signal.addEventListener('abort', () => { abortSeen = true; }, { once: true });
+        await new Promise(() => {});
+      },
+      cancel: async () => {
+        cancelCalled = true;
+      },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const base = `http://127.0.0.1:${handle.port}`;
+    const runResponse = await fetch(`${base}/run`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'build', workspace: 'docs' }),
+    });
+    assert.equal(runResponse.status, 202);
+
+    const killResponse = await fetch(`${base}/kill?workspace=docs`, { method: 'POST' });
+    assert.equal(killResponse.status, 202);
+    assert.deepEqual(await killResponse.json(), {
+      killed: true,
+      workspace: 'docs',
+      runId: null,
+      runs: 1,
+      tasks: 3,
+      queued: 1,
+    });
+    assert.equal(abortSeen, true);
+    assert.equal(cancelCalled, true);
+    assert.equal(interruptArgs.workspace, 'docs');
+    assert.equal(interruptArgs.runId, null);
+    assert.deepEqual(taskCancelArgs, { workspace: 'docs', runId: null });
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server kill succeeds without an active run', async (t) => {
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+        interruptRuns: () => 0,
+        cancelActiveTasksForInterruptedRuns: () => 0,
+      },
+      session: {},
+      run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/kill?workspace=docs`, { method: 'POST' });
+    assert.equal(response.status, 202);
+    assert.deepEqual(await response.json(), {
+      killed: true,
+      workspace: 'docs',
+      runId: null,
+      runs: 0,
+      tasks: 0,
+      queued: 0,
+    });
+  } finally {
+    await handle.close();
+  }
+});
+
+test('runtime server kill can target a specific run id', async (t) => {
+  let interruptArgs = null;
+  let taskCancelArgs = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+        interruptRuns: (args) => {
+          interruptArgs = args;
+          return 1;
+        },
+        cancelActiveTasksForInterruptedRuns: (args) => {
+          taskCancelArgs = args;
+          return 2;
+        },
+      },
+      session: {},
+      run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/kill?workspace=docs&runId=run-1`, { method: 'POST' });
+    assert.equal(response.status, 202);
+    assert.equal((await response.json()).runId, 'run-1');
+    assert.equal(interruptArgs.runId, 'run-1');
+    assert.deepEqual(taskCancelArgs, { workspace: 'docs', runId: 'run-1' });
+  } finally {
+    await handle.close();
+  }
+});
+
 test('runtime server state exposes active run identity while running', async (t) => {
   let releaseRun;
   const context = {
@@ -398,10 +553,10 @@ test('runtime server isolates active runs by workspace', async (t) => {
     const queued = await fetch(`${url}?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ input: 'third' }),
+      body: JSON.stringify({ input: 'third', intent: 'enqueue' }),
     });
     assert.equal(queued.status, 202);
-    assert.equal((await queued.json()).queued, true);
+    assert.equal((await queued.json()).kind, 'enqueue_run');
     assert.deepEqual(runWorkspaces.sort(), ['acme', 'docs']);
   } finally {
     releases.get('acme')?.();
@@ -1179,3 +1334,65 @@ test('runtime server rejects config switching while a run is active', async (t)
     await handle.close();
   }
 });
+
+test('runtime server answers control messages posted to /run during an active run', async (t) => {
+  let releaseRun;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'running' }),
+        listEvents: () => [],
+      },
+      session: {},
+      run: async () => {
+        await new Promise((resolve) => { releaseRun = resolve; });
+      },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const url = `http://127.0.0.1:${handle.port}/run`;
+    const started = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'lance le pipeline' }),
+    });
+    assert.equal(started.status, 202);
+
+    // A status question must be answered NOW, not parked until the run ends
+    // (regression: serve UI got no result until the job finished/stopped).
+    const observe = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'où en est le run ?' }),
+    });
+    assert.equal(observe.status, 200);
+    const observeBody = await observe.json();
+    assert.equal(observeBody.kind, 'observe');
+    assert.ok(String(observeBody.explanation ?? '').length > 0, 'observe must carry an explanation');
+
+    // A cancel must abort the active run instead of being enqueued.
+    const cancel = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'annule le run' }),
+    });
+    assert.equal(cancel.status, 200);
+    const cancelBody = await cancel.json();
+    assert.equal(cancelBody.kind, 'cancel');
+    assert.equal(cancelBody.accepted, true);
+  } finally {
+    releaseRun?.();
+    await handle.close();
+  }
+});

package/src/runtime/store.js

@@ -279,6 +279,11 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     SET status = 'interrupted', updated_at = ?
     WHERE workspace = ? AND status IN (${RECOVERABLE_RUN_STATUSES.map(() => '?').join(', ')})
   `);
+  const interruptRunByIdStatement = db.prepare(`
+    UPDATE runs
+    SET status = 'interrupted', updated_at = ?
+    WHERE id = ? AND (? IS NULL OR workspace = ?) AND status IN (${RECOVERABLE_RUN_STATUSES.map(() => '?').join(', ')})
+  `);
   const upsertQueueItem = db.prepare(`
     INSERT INTO queue_items (
       id, workspace, server, tool, args, lock_key, status, reason, job_id, activity_key,
@@ -413,6 +418,25 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
   `);
   const deleteTaskDependenciesStatement = db.prepare('DELETE FROM task_dependencies WHERE run_id = ? AND task_id = ?');
   const updateTaskStatusStatement = db.prepare('UPDATE tasks SET status = ?, declaration = ?, updated_at = ? WHERE run_id = ? AND id = ?');
+  const listActiveTasksForInterruptedRunsStatement = db.prepare(`
+    SELECT tasks.*
+    FROM tasks
+    JOIN runs ON runs.id = tasks.run_id
+    WHERE runs.workspace = ?
+      AND runs.status = 'interrupted'
+      AND tasks.status IN ('pending', 'pending_approval', 'waiting_approval', 'running', 'starting', 'blocked')
+    ORDER BY tasks.run_id ASC, tasks.id ASC
+  `);
+  const listActiveTasksForInterruptedRunByIdStatement = db.prepare(`
+    SELECT tasks.*
+    FROM tasks
+    JOIN runs ON runs.id = tasks.run_id
+    WHERE runs.id = ?
+      AND (? IS NULL OR runs.workspace = ?)
+      AND runs.status = 'interrupted'
+      AND tasks.status IN ('pending', 'pending_approval', 'waiting_approval', 'running', 'starting', 'blocked')
+    ORDER BY tasks.run_id ASC, tasks.id ASC
+  `);
   const insertTaskDependencyStatement = db.prepare(`
     INSERT OR IGNORE INTO task_dependencies (run_id, task_id, depends_on_task_id, created_at)
     VALUES (?, ?, ?, ?)
@@ -619,13 +643,33 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
       .map((row) => row.workspace);
   }
 
-  function interruptRuns({ workspace, reason = 'Runtime restart recovery failed.' } = {}) {
-    if (!workspace) return 0;
+  function interruptRuns({ workspace, runId = null, reason = 'Runtime restart recovery failed.' } = {}) {
+    if (!workspace && !runId) return 0;
     const now = new Date().toISOString();
-    const result = interruptRunsStatement.run(now, workspace, ...RECOVERABLE_RUN_STATUSES);
+    const result = runId
+      ? interruptRunByIdStatement.run(now, String(runId), workspace ?? null, workspace ?? null, ...RECOVERABLE_RUN_STATUSES)
+      : interruptRunsStatement.run(now, workspace, ...RECOVERABLE_RUN_STATUSES);
     return Number(result.changes ?? 0);
   }
 
+  function cancelActiveTasksForInterruptedRuns({ workspace = null, runId = null } = {}) {
+    if (!workspace && !runId) return 0;
+    const now = new Date().toISOString();
+    const tasks = runId
+      ? listActiveTasksForInterruptedRunByIdStatement.all(String(runId), workspace ?? null, workspace ?? null).map(rowToTask)
+      : listActiveTasksForInterruptedRunsStatement.all(workspace).map(rowToTask);
+    for (const task of tasks) {
+      updateTaskStatusStatement.run(
+        'cancelled',
+        JSON.stringify({ ...task.declaration, status: 'cancelled' }),
+        now,
+        task.runId,
+        task.id,
+      );
+    }
+    return tasks.length;
+  }
+
   function saveQueue(queue = [], { workspace = null } = {}) {
     const items = Array.isArray(queue) ? queue : [];
     const now = new Date().toISOString();
@@ -1121,6 +1165,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     listRecoverableRuns,
     listRecoverableWorkspaces,
     interruptRuns,
+    cancelActiveTasksForInterruptedRuns,
     saveQueue,
     listQueue,
     listTasks,

package/src/runtime/store.test.js

@@ -606,6 +606,38 @@ test('runtime store persists cancelled run status', () => {
   store.close();
 });
 
+test('runtime store interrupts runs by runId and does not recover killed runs after reopen', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  for (const runId of ['run-kill', 'run-keep']) {
+    store.persistEvent(createAgentEvent('run_started', {
+      origin: 'test',
+      runId,
+      workspace: 'docs',
+      payload: { input: runId, workspace: 'docs' },
+    }));
+    store.persistEvent(createAgentEvent('task.created', {
+      origin: 'test',
+      runId,
+      taskId: `${runId}:task`,
+      workspace: 'docs',
+      payload: { runId, task: { ...plannedTask(`${runId}:task`), status: 'running' } },
+    }));
+  }
+
+  assert.equal(store.interruptRuns({ workspace: 'docs', runId: 'run-kill' }), 1);
+  assert.equal(store.cancelActiveTasksForInterruptedRuns({ workspace: 'docs', runId: 'run-kill' }), 1);
+  assert.equal(store.listRuns().find((run) => run.id === 'run-kill').status, 'interrupted');
+  assert.equal(store.listRuns().find((run) => run.id === 'run-keep').status, 'running');
+  assert.equal(store.listTasks({ runId: 'run-kill' })[0].status, 'cancelled');
+  assert.equal(store.listTasks({ runId: 'run-keep' })[0].status, 'running');
+  store.close();
+
+  const reopened = openRuntimeStore({ stateDir });
+  assert.deepEqual(reopened.listRecoverableRuns({ workspace: 'docs' }).map((run) => run.id), ['run-keep']);
+  reopened.close();
+});
+
 test('runtime store migrates legacy databases without workspace columns', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const db = new DatabaseSync(join(stateDir, 'runtime.db'));

package/src/runtime/supervisor.js

@@ -98,8 +98,55 @@ export async function pollActivitiesOnce(session, {
           payload: { activity: polledActivity },
         }));
         syncQueueWithActivity(session, polledActivity);
-        emitRuntimeLog(session, `activity: ${polledActivity.label} -> ${polledActivity.status}`);
+        // Only log when something actually changed: the poll fires every
+        // second and an unchanged "activity: X -> running" line repeated
+        // dozens of times drowned Logs/Trace and looked like a frozen system.
+        // The line itself carries the operational signal (current file,
+        // percent, batch, last trace event, retry/backoff) so the panel
+        // reads as a narrative of the job, not a heartbeat.
+        const progress = payload?.progress ?? polledActivity.progress ?? {};
+        const percent = Number(progress.percent ?? polledActivity.progress?.percent);
+        const detail = progress.detail ?? progress.step ?? '';
+        // The trace's batchIndex is 0-based and the human detail already says
+        // "Batch 1/2" — printing both gave "Batch 1/2 · batch 0/2". Display
+        // 1-based, and only when the detail doesn't already carry it.
+        const batch = progress.batchIndex != null && progress.batchCount != null && !/batch/i.test(String(detail))
+          ? `batch ${Number(progress.batchIndex) + 1}/${progress.batchCount}`
+          : null;
+        const lastEvent = progress.lastEvent ? String(progress.lastEvent) : null;
+        const retry = progress.retryAt
+          ? `retry ${progress.retryAt}`
+          : (progress.waitMs ? `wait ${progress.waitMs}ms` : null);
+        const progressKey = `${polledActivity.status}:${Number.isFinite(percent) ? Math.round(percent) : ''}:${detail}:${batch ?? ''}:${lastEvent ?? ''}:${retry ?? ''}`;
+        session._activityLogKeys ??= {};
+        if (session._activityLogKeys[key] !== progressKey) {
+          session._activityLogKeys[key] = progressKey;
+          const progressLabel = [
+            Number.isFinite(percent) ? `${Math.round(percent)}%` : null,
+            detail ? String(detail) : null,
+            batch,
+            lastEvent,
+            retry,
+          ].filter(Boolean).join(' · ');
+          emitRuntimeLog(session, `activity: ${polledActivity.label} -> ${polledActivity.status}${progressLabel ? ` (${progressLabel})` : ''}`);
+        }
+        // Stream NEW job-log lines into Logs/Trace: document names, chunking,
+        // LLM call/token summaries and errors live in the job log, not in the
+        // status fields. Diff against the last line already shown.
+        const logTail = Array.isArray(payload?.logTail) ? payload.logTail.map(String) : [];
+        if (logTail.length > 0) {
+          session._activityLogCursors ??= {};
+          const lastSeen = session._activityLogCursors[key];
+          const lastIndex = lastSeen ? logTail.lastIndexOf(lastSeen) : -1;
+          for (const line of logTail.slice(lastIndex + 1)) {
+            const clean = line.trim();
+            if (clean) emitRuntimeLog(session, `job ${polledActivity.id ?? key}: ${clean}`);
+          }
+          session._activityLogCursors[key] = logTail.at(-1);
+        }
         if (polledActivity.terminal) {
+          delete session._activityLogKeys[key];
+          delete session._activityLogCursors?.[key];
           await startNextQueuedJob(session, {
             addLog: (message) => emitRuntimeLog(session, message),
           });
@@ -134,3 +181,32 @@ function registryIntervalFromEnv() {
   const value = Number(process.env.WIKI_MANAGER_AGENT_REGISTRY_INTERVAL_MS);
   return Number.isFinite(value) && value >= 0 ? Math.floor(value) : 60000;
 }
+
+// Cancelling a runtime run must also cancel the asynchronous jobs it started:
+// the run's abort only stopped the manager-side loop while the agent kept
+// executing (an ingest subprocess ran on for minutes after "cancel requested",
+// with the panels frozen on its last known state). Best effort: prefer the
+// orchestration contract's agent_cancel, fall back to legacy *_cancel_job.
+export async function cancelActiveActivityJobs(session, { callTool = callMcpTool } = {}) {
+  const cancelled = [];
+  for (const activity of sessionActivities(session)) {
+    if (activity.terminal || !activity.poll) continue;
+    const jobId = activity.poll.args?.jobId ?? activity.id ?? null;
+    const server = activity.poll.server;
+    const endpoint = session.mcp?.[server];
+    if (!jobId || !endpoint || endpoint.status !== 'connected') continue;
+    const names = (endpoint.tools ?? []).map((tool) => String(tool.name ?? ''));
+    const cancelTool = names.find((name) => /(^|__)agent_cancel$/.test(name))
+      ?? names.find((name) => /_cancel_job$/.test(name))
+      ?? names.find((name) => /(^|__)[a-z]*_?cancel$/.test(name));
+    if (!cancelTool) continue;
+    try {
+      await callTool(session.mcp, server, cancelTool, { jobId });
+      emitRuntimeLog(session, `cancel: requested ${server}.${cancelTool} for job ${jobId}`);
+      cancelled.push({ server, jobId });
+    } catch (err) {
+      emitRuntimeLog(session, `cancel: ${server}.${cancelTool} failed for ${jobId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return cancelled;
+}