@dotdrelle/wiki-manager 0.12.1 → 0.12.7

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

@@ -242,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: controlMessage(context?.session, 'queued_for_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);
@@ -274,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 });
@@ -355,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;
@@ -472,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,

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,