@dotdrelle/wiki-manager 0.12.1 → 0.12.7

package/src/core/agentEvents.test.js

@@ -279,6 +279,16 @@ test('reduceAgentEvents: control queue is event sourced and follows run status',
         createdAt: '2026-01-01T00:00:00.000Z',
       },
     }),
+    createAgentEvent('control_enqueued', {
+      origin: 'runtime',
+      workspace: 'docs',
+      payload: {
+        id: 'control-2',
+        workspace: 'docs',
+        input: 'Never run',
+        createdAt: '2026-01-01T00:00:01.000Z',
+      },
+    }),
     createAgentEvent('control_started', {
       origin: 'runtime',
       runId: 'run-control-1',
@@ -290,12 +300,19 @@ test('reduceAgentEvents: control queue is event sourced and follows run status',
       runId: 'run-control-1',
       workspace: 'docs',
     }),
+    createAgentEvent('control_cancelled', {
+      origin: 'runtime',
+      workspace: 'docs',
+      payload: { id: 'control-2' },
+    }),
   ]);
 
-  assert.equal(projection.controlQueue.length, 1);
+  assert.equal(projection.controlQueue.length, 2);
   assert.equal(projection.controlQueue[0].id, 'control-1');
   assert.equal(projection.controlQueue[0].status, 'done');
   assert.equal(projection.controlQueue[0].runId, 'run-control-1');
+  assert.equal(projection.controlQueue[1].id, 'control-2');
+  assert.equal(projection.controlQueue[1].status, 'cancelled');
 });
 
 test('reduceAgentEvents: activity-owned plan is used when no orchestrator plan exists', () => {
@@ -399,3 +416,27 @@ test('reduceAgentEvents: plan patches are proposed, approved and applied with re
   assert.equal(projection.plan[1].status, 'pending');
   assert.equal(projection.planPatches[0].status, 'applied');
 });
+
+test('streamed narration split across tool iterations yields separate conversation entries', () => {
+  // graph.js finalizes the streaming entry (assistant_message content:'')
+  // before each tool batch so per-iteration narrations do not glue together
+  // into one wall of text.
+  const session = {};
+  dispatchAgentEvent(session, createAgentEvent('assistant_delta', { origin: 'llm', payload: { delta: 'Analyse des jobs récents.' } }));
+  dispatchAgentEvent(session, createAgentEvent('assistant_message', { origin: 'llm', payload: { content: '' } }));
+  dispatchAgentEvent(session, createAgentEvent('assistant_delta', { origin: 'llm', payload: { delta: 'Voyons les logs.' } }));
+  dispatchAgentEvent(session, createAgentEvent('assistant_message', { origin: 'llm', payload: { content: 'Voyons les logs.' } }));
+
+  const conversation = session.agentProjection.conversation;
+  assert.equal(conversation.length, 2);
+  assert.equal(conversation[0].content, 'Analyse des jobs récents.');
+  assert.equal(conversation[0].streaming ?? false, false);
+  assert.equal(conversation[1].content, 'Voyons les logs.');
+});
+
+test('empty assistant_message finalize is a no-op without a streaming entry', () => {
+  const session = {};
+  dispatchAgentEvent(session, createAgentEvent('assistant_message', { origin: 'llm', payload: { content: 'Réponse finale.' } }));
+  dispatchAgentEvent(session, createAgentEvent('assistant_message', { origin: 'llm', payload: { content: '' } }));
+  assert.equal(session.agentProjection.conversation.length, 1);
+});

package/src/core/buildInfo.js

@@ -0,0 +1,58 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, '..', '..');
+
+let cachedCommit;
+
+// Short git commit identifying the code actually running. Resolution order:
+// 1. Live git HEAD when running from the development repository — accurate
+//    even between releases (dirty trees still show the base commit).
+// 2. buildInfo.json generated at pack time (scripts/check-versions.js) —
+//    what a published/global install carries.
+// 3. null — displayed as "+dev" so an untraceable build is visible at a
+//    glance instead of silently pretending to match the repo.
+export function buildCommit() {
+  if (cachedCommit !== undefined) return cachedCommit;
+  cachedCommit = liveGitCommit() ?? packagedCommit();
+  return cachedCommit;
+}
+
+export function versionWithBuild(packageJson) {
+  const version = String(packageJson?.version ?? '').trim();
+  const commit = buildCommit();
+  return commit ? `${version}+${commit}` : `${version}+dev`;
+}
+
+function liveGitCommit() {
+  try {
+    // Guard against walking up into an unrelated parent repository when the
+    // package is installed under a directory that happens to be git-tracked.
+    const toplevel = git(['rev-parse', '--show-toplevel']);
+    if (!toplevel || resolve(toplevel) !== packageRoot) return null;
+    return git(['rev-parse', '--short', 'HEAD']);
+  } catch {
+    return null;
+  }
+}
+
+function git(args) {
+  const output = execFileSync('git', args, {
+    cwd: packageRoot,
+    stdio: ['ignore', 'pipe', 'ignore'],
+    timeout: 2000,
+  }).toString().trim();
+  return output || null;
+}
+
+function packagedCommit() {
+  try {
+    const info = JSON.parse(readFileSync(join(here, 'buildInfo.json'), 'utf8'));
+    return info?.commit ? String(info.commit) : null;
+  } catch {
+    return null;
+  }
+}

package/src/core/buildInfo.json

@@ -0,0 +1,4 @@
+{
+  "version": "0.12.7",
+  "commit": "0bab10f"
+}

package/src/core/buildInfo.test.js

@@ -0,0 +1,14 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { buildCommit, versionWithBuild } from './buildInfo.js';
+
+test('versionWithBuild always exposes a provenance suffix', () => {
+  const formatted = versionWithBuild({ version: '9.9.9' });
+  // From the development repo the live git short sha is used; from a packed
+  // install the buildInfo.json commit; '+dev' only when neither is available.
+  assert.match(formatted, /^9\.9\.9\+(?:[0-9a-f]{4,40}|dev)$/);
+});
+
+test('buildCommit is stable across calls (cached)', () => {
+  assert.equal(buildCommit(), buildCommit());
+});

package/src/core/mcp.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { managerEnvFile, managerMcpEndpointsFile, readEnvFile } from './env.js';
 
-const WIKI_MANAGER_VERSION = '0.12.1';
+const WIKI_MANAGER_VERSION = '0.12.7';
 
 function envValue(key) {
   const filePath = managerEnvFile();
@@ -302,6 +302,26 @@ export function formatMcpToolResult(result) {
     .trim() || 'No result.';
 }
 
+const DEFAULT_TOOL_RESULT_MAX_CHARS = 16000;
+
+function toolResultMaxChars() {
+  const parsed = Number(process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : DEFAULT_TOOL_RESULT_MAX_CHARS;
+}
+
+// Bound what a tool result injects into the LLM context and the conversation
+// display. Apply this ONLY at those two exit points — never before payload
+// parsing (extractActivity/_activity detection needs the full text).
+// Head + tail are kept because errors and job ids often live at either end.
+export function truncateToolResult(text, maxChars = toolResultMaxChars()) {
+  const full = String(text ?? '');
+  if (full.length <= maxChars) return full;
+  const headLength = Math.floor(maxChars * 0.7);
+  const tailLength = Math.floor(maxChars * 0.2);
+  const omitted = full.length - headLength - tailLength;
+  return `${full.slice(0, headLength)}\n\n[… ${omitted} caractères tronqués — résultat complet dans les logs runtime …]\n\n${full.slice(-tailLength)}`;
+}
+
 let _cachedEnvRetryPolicy = null;
 function getEnvRetryPolicy() {
   if (!_cachedEnvRetryPolicy) {

package/src/core/mcp.test.js

@@ -10,6 +10,7 @@ import {
   formatMcpToolsForAgent,
   resolveRetryPolicy,
   resolveToolCallName,
+  truncateToolResult,
 } from './mcp.js';
 
 const resolveFixtureStatus = {
@@ -516,3 +517,27 @@ test('callMcpTool parses SSE responses after keepalive comments', async () => {
     globalThis.fetch = originalFetch;
   }
 });
+
+test('truncateToolResult keeps short results intact and bounds long ones head+tail', () => {
+  assert.equal(truncateToolResult('short result', 100), 'short result');
+
+  const long = `START-${'x'.repeat(50000)}-END`;
+  const bounded = truncateToolResult(long, 1000);
+  assert.ok(bounded.length < 1200, `bounded length ${bounded.length} should stay near the cap`);
+  assert.match(bounded, /^START-/);
+  assert.match(bounded, /-END$/);
+  assert.match(bounded, /caractères tronqués/);
+});
+
+test('truncateToolResult honours WIKI_MANAGER_TOOL_RESULT_MAX_CHARS', () => {
+  const previous = process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS;
+  process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS = '500';
+  try {
+    const bounded = truncateToolResult('y'.repeat(5000));
+    assert.ok(bounded.length < 700);
+    assert.match(bounded, /caractères tronqués/);
+  } finally {
+    if (previous === undefined) delete process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS;
+    else process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS = previous;
+  }
+});

package/src/core/runtimeLog.js

@@ -61,7 +61,12 @@ export function normalizeRuntimeLog(input, { session = null } = {}) {
 }
 
 export function formatRuntimeLogPayload(payload = {}, ts = null) {
-  if (payload?.message != null && !payload.event) return String(payload.message);
+  // Plain messages get the same time prefix as structured events: untimed
+  // lines ended up visually glued at the bottom of Logs/Trace, out of
+  // chronology with the shell's own timestamped lines.
+  if (payload?.message != null && !payload.event) {
+    return [timeLabel(ts), String(payload.message)].filter(Boolean).join(' ');
+  }
   const time = timeLabel(ts);
   const event = eventLabel(payload.event);
   const fields = ORDERED_FIELDS

package/src/core/runtimeLog.test.js

@@ -80,5 +80,7 @@ test('emitRuntimeLog accepts structured payloads and preserves legacy strings',
   assert.match(session.agentProjection.logs[0], /ASSIGNED/);
   assert.match(session.agentProjection.logs[0], /run=run-structured/);
   assert.match(session.agentProjection.logs[0], /workspace=docs/);
-  assert.equal(session.agentProjection.logs[1], 'legacy line');
+  // Legacy plain messages now carry the same HH:MM:SS prefix as structured
+  // events so the Logs/Trace panel stays chronologically readable.
+  assert.match(session.agentProjection.logs[1], /^\d{2}:\d{2}:\d{2} legacy line$/);
 });

package/src/runtime/client.js

@@ -10,6 +10,14 @@ function runtimeEndpoint(url, path, workspace = null) {
   return endpoint.toString();
 }
 
+function runtimeEndpointWithParams(url, path, params = {}) {
+  const endpoint = new URL(`${base(url)}${path}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value != null && value !== '') endpoint.searchParams.set(key, String(value));
+  }
+  return endpoint.toString();
+}
+
 export function runtimeUrlFromEnv() {
   return process.env.WIKI_MANAGER_RUNTIME_URL ?? 'http://127.0.0.1:7788';
 }
@@ -97,6 +105,20 @@ export async function postRuntimeCancel({
   return response.json();
 }
 
+export async function postRuntimeKill({
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+  workspace = null,
+  runId = null,
+} = {}) {
+  const response = await fetch(runtimeEndpointWithParams(url, '/kill', { workspace, runId }), {
+    method: 'POST',
+    headers: runtimeHeaders(token),
+  });
+  if (!response.ok && response.status !== 501) throw new Error(`Runtime kill failed: HTTP ${response.status}`);
+  return response.json();
+}
+
 export async function postRuntimeShutdown({
   url = runtimeUrlFromEnv(),
   token = runtimeToken(),

package/src/runtime/controlMessages.js

@@ -18,8 +18,8 @@ const CONTROL_MESSAGES = {
     fr: 'Modification de plan proposée. Approuvez-la explicitement pour l’appliquer au plan actif.',
   },
   ambiguous_control: {
-    en: 'The runtime cannot safely classify this message.',
-    fr: 'Le runtime ne peut pas classer ce message de façon sûre.',
+    en: 'A run is already active, and this looks like a new action. Say "queue it" to run it after the current run, "modify the run" to change the active plan, "cancel" to stop the current run first — or wait for it to finish.',
+    fr: 'Un run est déjà actif et ta demande ressemble à une nouvelle action. Dis « mets en file » pour l\'exécuter après le run en cours, « modifie le run » pour changer le plan actif, « annule » pour arrêter le run actuel — ou attends la fin.',
   },
   converse_while_running: {
     en: 'Runtime run is still active. This message was treated as conversation and did not create a queued run.',

package/src/runtime/recoveryManager.js

@@ -1,6 +1,7 @@
 import { parseJsonText } from '../core/activity.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { formatMcpToolResult, callMcpTool as defaultCallMcpTool } from '../core/mcp.js';
+import { createCapabilityRegistry } from '../orchestrator/capabilityRegistry.js';
 import { accept as acceptResult } from '../orchestrator/resultAggregator.js';
 
 const ACTIVE_TASK_STATUSES = new Set(['running', 'queued', 'starting', 'assigned']);
@@ -24,9 +25,11 @@ export async function recoverActiveRuns({
   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()));
+    const runOutcomes = [];
     for (const task of activeTasks) {
       try {
         const outcome = await recoverTask({ store, session, run, task, callTool, resultAggregator });
+        runOutcomes.push(outcome ?? null);
         if (outcome?.status === 'recovered') recovered.push(outcome);
         else if (outcome?.status === 'rescheduled') rescheduled.push(outcome);
         else if (outcome?.status === 'interrupted') interrupted.push(outcome);
@@ -34,6 +37,21 @@ export async function recoverActiveRuns({
         errors.push({ runId: run.id, taskId: task.id, error: error instanceof Error ? error.message : String(error) });
       }
     }
+    // A run in which nothing was recovered or rescheduled can never progress:
+    // leaving it 'running' in the store would re-attach it as a zombie on
+    // every subsequent boot. Close it for good.
+    if (activeTasks.length > 0 && runOutcomes.length === activeTasks.length
+      && runOutcomes.every((outcome) => outcome?.status === 'interrupted')) {
+      const changed = store.interruptRuns?.({ workspace: run.workspace ?? null, runId: run.id, reason: 'Recovery found no recoverable task.' }) ?? 0;
+      if (changed > 0) {
+        dispatch(session, store, 'runtime_log', {
+          origin: 'recovery_manager',
+          runId: run.id,
+          workspace: run.workspace ?? workspaceFromSession(session),
+          payload: { message: `recovery: run ${run.id} interrupted (no recoverable task)` },
+        });
+      }
+    }
   }
 
   return {
@@ -46,6 +64,28 @@ export async function recoverActiveRuns({
 }
 
 async function recoverTask({ store, session, run, task, callTool, resultAggregator }) {
+  // A task whose capability no longer resolves can never be dispatched:
+  // re-attaching it would recreate the forever-waiting queue it came from.
+  // Fail it explicitly instead. No registry information at all (discovery
+  // not run yet) keeps the current behavior.
+  if (task.requiredCapability && !capabilityResolvable(session, task.requiredCapability)) {
+    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: 'failed',
+        recovery: {
+          reason: 'unresolvable_capability',
+          capability: task.requiredCapability,
+        },
+      },
+    });
+    return interruptTask({ store, session, run, task, reason: `unresolvable capability: ${task.requiredCapability}` });
+  }
+
   const attempt = latestAttempt(store.listTaskAttempts?.({ taskId: task.id }) ?? []);
   const assignment = latestAssignment(store.listTaskAssignments?.({ taskId: task.id }) ?? [], attempt?.attemptId);
   if (!attempt?.jobId || !assignment?.agentInstanceId) {
@@ -126,6 +166,20 @@ function isTerminal(status) {
   return TERMINAL_STATUSES.has(String(status ?? '').toLowerCase());
 }
 
+function capabilityResolvable(session, capability) {
+  const registry = session.capabilityRegistry
+    ?? ((session.agentRegistrySnapshot ?? []).length > 0
+      ? createCapabilityRegistry({ agents: session.agentRegistrySnapshot })
+      : null);
+  if (!registry || typeof registry.providersFor !== 'function') return true;
+  // Only trust a registry that actually knows about capabilities. An empty
+  // one (discovery not finished, or agents described without capability
+  // lists) cannot distinguish "nothing provides X" from "no information".
+  const snapshot = typeof registry.snapshot === 'function' ? registry.snapshot() : {};
+  if (Object.keys(snapshot ?? {}).length === 0) return true;
+  return registry.providersFor(capability).length > 0;
+}
+
 function parseToolPayload(result) {
   if (result && typeof result === 'object' && !Array.isArray(result) && !Array.isArray(result.content)) return result;
   return parseJsonText(formatMcpToolResult(result)) ?? {};

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')