@dotdrelle/wiki-manager 0.12.10 → 0.12.12

package/src/contracts/schemas.js

@@ -131,6 +131,38 @@ const agentDescriptionSchema = {
   },
 };
 
+const pendingInputSchema = {
+  $id: 'https://dotdrelle.dev/wiki-manager/contracts/pending-input/v1',
+  title: 'PendingInput',
+  schemaVersion: '1',
+  type: 'object',
+  required: ['type', 'ref'],
+  additionalProperties: true,
+  properties: {
+    type: { type: 'string', minLength: 1 },
+    ref: { type: 'string', minLength: 1 },
+    label: nullableString,
+    mediaType: nullableString,
+  },
+};
+
+const capabilityStatusSchema = {
+  $id: 'https://dotdrelle.dev/wiki-manager/contracts/capability-status/v1',
+  title: 'CapabilityStatus',
+  schemaVersion: '1',
+  type: 'object',
+  required: ['contractVersion', 'agentInstanceId', 'capability', 'operation', 'available', 'pendingInputs'],
+  additionalProperties: true,
+  properties: {
+    contractVersion: { type: 'string', minLength: 1 },
+    agentInstanceId: { type: 'string', minLength: 1 },
+    capability: { type: 'string', minLength: 1 },
+    operation: { type: 'string', minLength: 1 },
+    available: { type: 'boolean' },
+    pendingInputs: { type: 'array', items: pendingInputSchema },
+  },
+};
+
 const taskGroupSchema = {
   $id: 'https://dotdrelle.dev/wiki-manager/contracts/task-group/v1',
   title: 'TaskGroup',
@@ -424,6 +456,7 @@ export const contractSchemas = {
   outputReference: outputReferenceSchema,
   capabilityDescription: capabilityDescriptionSchema,
   agentDescription: agentDescriptionSchema,
+  capabilityStatus: capabilityStatusSchema,
   retryPolicy: retryPolicySchema,
   taskGroup: taskGroupSchema,
   plannedTask: plannedTaskSchema,

package/src/contracts/schemas.test.js

@@ -236,3 +236,17 @@ test('agent description contract validates orchestrable agent capabilities', ()
   assert.equal(validateContract('capabilityDescription', description.capabilities[0]).ok, true);
   assert.equal(validateContract('agentDescription', { ...description, health: { status: 'offline' } }).ok, false);
 });
+
+test('capability status contract carries dynamic pending inputs without prescribing storage paths', () => {
+  const status = {
+    contractVersion: '1',
+    agentInstanceId: 'production-main',
+    capability: 'knowledge.update',
+    operation: 'ingest',
+    available: true,
+    pendingInputs: [{ type: 'file', ref: 'provider-owned/source-a', label: 'source-a.md', mediaType: 'text/markdown' }],
+  };
+
+  assert.equal(validateContract('capabilityStatus', status).ok, true);
+  assert.equal(validateContract('capabilityStatus', { ...status, pendingInputs: [{ type: 'file' }] }).ok, false);
+});

package/src/core/agentEvents.js

@@ -490,6 +490,12 @@ function applyEvent(state, event) {
     case 'run_error':
       state.status = 'error';
       state.logs.push(String(event.payload?.message ?? 'Agent run failed.'));
+      // A dead run must not leave "pending" plan steps and spinning
+      // activities in the persisted projection: they reappeared as ghosts
+      // at every relaunch ("des trucs dans le plan qui n'existent pas") and
+      // /kill honestly reported 0 because nothing was actually running.
+      cancelPendingPlanSteps(state.plan);
+      cancelActiveActivities(state.activities, event.ts);
       finishControlByRun(state.controlQueue, event.runId ?? event.payload?.runId ?? null, 'failed', event.ts);
       return;
     case 'control_enqueued':

package/src/core/agentEvents.test.js

@@ -440,3 +440,29 @@ test('empty assistant_message finalize is a no-op without a streaming entry', ()
   dispatchAgentEvent(session, createAgentEvent('assistant_message', { origin: 'llm', payload: { content: '' } }));
   assert.equal(session.agentProjection.conversation.length, 1);
 });
+
+test('run_error cancels pending plan steps and active activities (no ghosts at relaunch)', () => {
+  const session = {};
+  dispatchAgentEvent(session, createAgentEvent('plan_set', {
+    origin: 'runtime',
+    payload: { steps: [
+      { id: 'a', description: 'Ingest a.md', status: 'pending', requiredCapability: 'knowledge.update', operation: 'ingest_plan' },
+      { id: 'b', description: 'Ingest b.md', status: 'done' },
+    ] },
+  }));
+  dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
+    origin: 'runtime_poll',
+    payload: { activity: { key: 'production:j1', id: 'j1', label: 'Ingest', status: 'running', terminal: false } },
+  }));
+  dispatchAgentEvent(session, createAgentEvent('run_error', {
+    origin: 'runtime',
+    payload: { message: 'Plan is stalled: no_ready_plan_task' },
+  }));
+
+  const plan = session.agentProjection.plan;
+  assert.equal(plan.find((step) => step.id === 'a').status, 'cancelled');
+  assert.equal(plan.find((step) => step.id === 'b').status, 'done', 'completed work stays done');
+  const activity = session.agentProjection.activities.find((item) => item.id === 'j1');
+  assert.equal(activity.status, 'cancelled');
+  assert.equal(activity.terminal, true);
+});

package/src/core/agentLoop.js

@@ -1,7 +1,7 @@
 import { buildAgentSystemPrompt, formatLlmUnavailableMessage } from '../agent/graph.js';
 import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
 import { activitySnapshot, newNonTerminalActivities } from './activity.js';
-import { extractHeadlessPlan, formatCompletedActivities, formatPlanStatus } from './plan.js';
+import { formatCompletedActivities, formatPlanStatus } from './plan.js';
 import { formatReadyTaskPrompt, nextReadyPlanTask, readyPlanTasks, sanitizePlanForExecution } from './planPatch.js';
 
 export function abortError(message = 'Agent run cancelled.') {
@@ -66,12 +66,17 @@ export async function runAgenticLoop(agent, session, initialInput, {
   onPendingSteps = null,
   onActivitiesStarted = null,
   onActivitiesCompleted = null,
+  deterministicTerminalSummary = false,
   onMaxTurns = null,
   abortMessage = 'Agent run cancelled.',
   parallelHandoff = false,
+  initialMessages = [],
 } = {}) {
   if (!waitForActivities) throw new Error('runAgenticLoop requires waitForActivities.');
-  const conversationHistory = [];
+  // Seeded with the chat that led to this run: a run that starts amnesiac
+  // receives an orphan sentence ("lance l'ingestion") and the model invents
+  // the missing context — the root of most "Donna répond sans savoir".
+  const conversationHistory = [...initialMessages];
   let currentInput = initialInput;
 
   for (let turn = 1; turn <= maxTurns; turn += 1) {
@@ -94,21 +99,16 @@ export async function runAgenticLoop(agent, session, initialInput, {
       { role: 'assistant', content: response },
     );
 
-    if (turn === 1) {
-      if (session.headlessPlan === null) {
-        const extractedPlan = extractHeadlessPlan(response);
-        if (extractedPlan) {
-          dispatchAgentEvent(session, createAgentEvent('plan_set', {
-            origin: planOrigin,
-            runId,
-            payload: { steps: extractedPlan },
-          }));
-          onPlanExtracted?.({ steps: session.headlessPlan ?? extractedPlan, fallback: true });
-        }
-      } else {
-        onPlanAlreadySet?.({ steps: session.headlessPlan });
-      }
+    if (turn === 1 && session.headlessPlan !== null) {
+      onPlanAlreadySet?.({ steps: session.headlessPlan });
     }
+    // NOTE: the deprecated text-plan extraction is gone. It converted any
+    // numbered list in a chatty LLM answer into an executable plan — the
+    // model's own questions ("Souhaitez-vous que je vous guide ?") became
+    // pending tasks, each step re-invoked the LLM, which produced another
+    // list… an infinite work-inventing loop. Plans now come ONLY from
+    // explicit channels: wiki__plan_set, _activity.plan.steps, or an
+    // integrated agent_plan fragment. Prose stays prose.
     sanitizeSessionPlan(session, { runId });
 
     const newPending = newNonTerminalActivities(snapshot, session);
@@ -149,6 +149,11 @@ export async function runAgenticLoop(agent, session, initialInput, {
     const completed = waitResult.completed ?? [];
     const summary = formatCompletedActivities(completed);
     onActivitiesCompleted?.({ completed, summary });
+    const unfinished = (session.headlessPlan ?? []).some((step) =>
+      ['pending', 'pending_approval', 'running', 'starting', 'queued'].includes(String(step.status ?? '').toLowerCase()));
+    if (deterministicTerminalSummary && !unfinished) {
+      return { ok: true, completed, summary, deterministicSummary: true };
+    }
     if (parallelHandoff && readyPlanTasks(session.headlessPlan).length > 1) {
       return { ok: true, handoff: true };
     }

package/src/core/agentLoop.test.js

@@ -77,27 +77,77 @@ test('runAgenticLoop waits for new activities and continues with a completion su
   assert.equal(result.ok, true);
   assert.equal(inputs.length, 2);
   assert.match(inputs[1], /Completed activities:/);
-  assert.match(inputs[1], /production job-1: done/);
-  assert.deepEqual(callbacks, ['started:1', '- production job-1: done']);
+  assert.match(inputs[1], /- job: done/);
+  assert.deepEqual(callbacks, ['started:1', '- job: done']);
 });
 
-test('runAgenticLoop extracts a fallback numbered plan from first response', async () => {
+test('runAgenticLoop can finish from terminal activity facts without another LLM turn', async () => {
+  const session = { activities: {}, headlessPlan: null };
+  let turns = 0;
+  const result = await runAgenticLoop({
+    async invoke({ session: turnSession }) {
+      turns += 1;
+      dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+        payload: {
+          activity: {
+            id: 'job-build',
+            source: 'production',
+            kind: 'build',
+            label: 'Build workspace',
+            status: 'running',
+            terminal: false,
+          },
+        },
+      }));
+      return { response: 'Job started.' };
+    },
+  }, session, 'Build workspace', {
+    maxTurns: 3,
+    timeoutMs: 1000,
+    deterministicTerminalSummary: true,
+    waitForActivities: async (turnSession) => {
+      dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+        payload: {
+          activity: {
+            id: 'job-build',
+            source: 'production',
+            kind: 'build',
+            label: 'Build workspace',
+            status: 'done',
+            terminal: true,
+            outputRefs: ['deliverables/result.md'],
+          },
+        },
+      }));
+      return { ok: true, completed: Object.values(turnSession.activities) };
+    },
+  });
+
+  assert.equal(turns, 1);
+  assert.equal(result.deterministicSummary, true);
+  assert.match(result.summary, /build: done/);
+  assert.match(result.summary, /output: deliverables\/result\.md/);
+});
+
+test('runAgenticLoop never turns a chatty numbered answer into a plan', async () => {
+  // Regression guard for the removed text-plan extraction: the model's own
+  // numbered prose ("1. … 2. … Souhaitez-vous… ?") used to become pending
+  // tasks and re-invoke the LLM in an infinite work-inventing loop. A chatty
+  // answer with no declared plan and no activity is simply a COMPLETE reply.
   const session = {
     activities: {},
     headlessPlan: null,
   };
   const result = await runAgenticLoop({
     async invoke() {
-      return { response: '1. Collect sources\n2. Build page' };
+      return { response: '1. Collect sources\n2. Build page\nSouhaitez-vous que je vous guide ?' };
     },
   }, session, 'Plan task', {
-    maxTurns: 1,
+    maxTurns: 3,
     timeoutMs: 1000,
     waitForActivities: async () => assert.fail('No activities should be waited for.'),
   });
 
-  assert.equal(result.ok, false);
-  assert.equal(result.maxTurns, true);
-  assert.equal(session.headlessPlan.length, 2);
-  assert.equal(session.headlessPlan[0].description, 'Collect sources');
+  assert.equal(result.ok, true, 'the run completes with the reply instead of inventing steps');
+  assert.equal(session.headlessPlan, null);
 });

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.12.10",
-  "commit": "e256e16"
+  "version": "0.12.12",
+  "commit": "e1e43ae"
 }

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.10';
+const WIKI_MANAGER_VERSION = '0.12.12';
 
 function envValue(key) {
   const filePath = managerEnvFile();
@@ -305,8 +305,7 @@ export function formatMcpToolResult(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;
+  return DEFAULT_TOOL_RESULT_MAX_CHARS;
 }
 
 // Bound what a tool result injects into the LLM context and the conversation

package/src/core/mcp.test.js

@@ -529,15 +529,3 @@ test('truncateToolResult keeps short results intact and bounds long ones head+ta
   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/plan.js

@@ -141,10 +141,17 @@ export function formatConfigValue(value) {
 }
 
 export function formatCompletedActivities(activities) {
-  return activities
-    .filter((a) => a.terminal)
-    .map((a) => `- ${a.source} ${a.id ?? a.kind}: ${a.status}${a.error ? ` (${a.error})` : ''}`)
-    .join('\n');
+  const terminal = activities.filter((activity) => activity.terminal);
+  const lines = terminal.map((activity) => {
+    const label = activity.kind ?? activity.label ?? `${activity.source} ${activity.id ?? 'activity'}`;
+    return `- ${label}: ${activity.status}${activity.error ? ` (${activity.error})` : ''}`;
+  });
+  const outputs = [...new Set(terminal.flatMap((activity) => activity.outputRefs ?? []).map((ref) => {
+    if (ref && typeof ref === 'object') return String(ref.ref ?? ref.path ?? ref.url ?? '').trim();
+    return String(ref ?? '').trim();
+  }).filter(Boolean))];
+  if (outputs.length > 0) lines.push(...outputs.map((output) => `- output: ${output}`));
+  return lines.join('\n');
 }
 
 function findMatchingPlanStepByStructure(plan, activity) {

package/src/orchestrator/scheduler.js

@@ -9,6 +9,30 @@ export function resolveSchedulerConcurrency(value = process.env.WIKI_MANAGER_SCH
     : DEFAULT_SCHEDULER_CONCURRENCY;
 }
 
+export function resolvePlanConcurrency({ plan = [], agents = [], configured = null } = {}) {
+  const capabilities = new Set(plan.map((task) => task?.requiredCapability).filter(Boolean).map(String));
+  const assignedAgents = new Set(plan.map((task) => task?.agentInstanceId).filter(Boolean).map(String));
+  const relevantAgents = agents.filter((agent) => {
+    const id = String(agent?.agentInstanceId ?? agent?.description?.agentInstanceId ?? '');
+    if (id && assignedAgents.has(id)) return true;
+    return (agent?.description?.capabilities ?? []).some((capability) => capabilities.has(String(capability?.id ?? '')));
+  });
+  const values = [
+    positiveInteger(configured),
+    ...plan.flatMap(concurrencyValues),
+    ...relevantAgents.flatMap(concurrencyValues),
+  ].filter(Boolean);
+  return values.length > 0 ? Math.max(1, Math.min(...values)) : DEFAULT_SCHEDULER_CONCURRENCY;
+}
+
+export function resolveCapabilityConcurrency(agent = null, ...constraints) {
+  const values = [
+    ...concurrencyValues(agent),
+    ...constraints.map(positiveInteger),
+  ].filter(Boolean);
+  return values.length > 0 ? Math.max(1, Math.min(...values)) : DEFAULT_SCHEDULER_CONCURRENCY;
+}
+
 export function effectiveConcurrency(group = null, agent = null, donna = null, provider = null) {
   const limits = [
     ...concurrencyValues(donna),

package/src/orchestrator/scheduler.test.js

@@ -6,7 +6,12 @@ import test from 'node:test';
 import { createBudgetManager } from './budgetManager.js';
 import { readyTasks } from './dependencyResolver.js';
 import { createLockManager } from './lockManager.js';
-import { effectiveConcurrency, startReadyTasks } from './scheduler.js';
+import {
+  effectiveConcurrency,
+  resolveCapabilityConcurrency,
+  resolvePlanConcurrency,
+  startReadyTasks,
+} from './scheduler.js';
 
 test('dependencyResolver holds a barrier task until its dependsOnGroup is done', () => {
   const plan = [
@@ -76,6 +81,40 @@ test('scheduler.effectiveConcurrency returns the minimum effective concurrency',
   assert.equal(effectiveConcurrency(group, agent, donna, provider), 2);
 });
 
+test('scheduler uses the relevant agent declaration instead of hard-capping plans at three', () => {
+  const plan = [{ id: 'task-1', requiredCapability: 'ingest' }];
+  const agents = [{
+    description: {
+      capabilities: [{ id: 'ingest' }],
+      limits: { recommendedConcurrency: 10, maxConcurrency: 12 },
+    },
+  }];
+
+  assert.equal(resolvePlanConcurrency({ plan, agents }), 10);
+  assert.equal(resolvePlanConcurrency({ plan, agents, configured: 3 }), 3);
+  assert.equal(resolvePlanConcurrency({ plan, agents, configured: 20 }), 10);
+});
+
+test('scheduler ignores unrelated agents and falls back to three without declarations', () => {
+  const plan = [{ id: 'task-1', requiredCapability: 'ingest' }];
+  const agents = [{
+    description: {
+      capabilities: [{ id: 'production' }],
+      limits: { recommendedConcurrency: 1 },
+    },
+  }];
+
+  assert.equal(resolvePlanConcurrency({ plan, agents }), 3);
+});
+
+test('capability constraints can lower but never raise an agent declaration', () => {
+  const agent = { description: { limits: { recommendedConcurrency: 6, maxConcurrency: 10 } } };
+
+  assert.equal(resolveCapabilityConcurrency(agent), 6);
+  assert.equal(resolveCapabilityConcurrency(agent, 2), 2);
+  assert.equal(resolveCapabilityConcurrency(agent, 20), 6);
+});
+
 test('startReadyTasks starts only ready tasks and respects lock starvation', () => {
   const active = new Map();
   const lockManager = createLockManager();

package/src/runtime/client.js

@@ -52,6 +52,7 @@ export async function postRuntimeRun(input, {
   workspace = null,
   evaluate = undefined,
   replans = undefined,
+  capabilityPlan = undefined,
 } = {}) {
   const response = await fetch(runtimeEndpoint(url, '/run', workspace), {
     method: 'POST',
@@ -59,7 +60,7 @@ export async function postRuntimeRun(input, {
       ...runtimeHeaders(token),
       'Content-Type': 'application/json',
     },
-    body: JSON.stringify(Object.assign({ input, workspace }, evaluate !== undefined && { evaluate }, replans !== undefined && { replans })),
+    body: JSON.stringify(Object.assign({ input, workspace }, evaluate !== undefined && { evaluate }, replans !== undefined && { replans }, capabilityPlan !== undefined && { capabilityPlan })),
   });
   if (!response.ok) {
     const err = new Error(`Runtime run failed: HTTP ${response.status}`);

package/src/runtime/lifecycle.js

@@ -109,7 +109,7 @@ export async function runtimeHealthOrNull(url = runtimeUrlFromEnv(), token = run
 // alive after exit produced zombie runtimes running yesterday's code and
 // yesterday's endpoints. Nuance preserved: if a run is active anywhere, the
 // runtime is left alive so the run survives the shell (that promise stays).
-export async function shutdownOwnedRuntime(runtime, { log = () => {} } = {}) {
+export async function shutdownOwnedRuntime(runtime, { log = (_message) => {} } = {}) {
   if (!runtime?.url || !runtime?.started) return { action: 'kept', reason: 'not_owned' };
   try {
     const health = await runtimeHealthOrNull(runtime.url, runtime.token);

package/src/runtime/runner.js

@@ -9,10 +9,16 @@ import { createBudgetManager, BudgetExceededError } from '../orchestrator/budget
 import { createDispatcher } from '../orchestrator/dispatcher.js';
 import { assertValidatedFragment } from '../orchestrator/planValidator.js';
 import { createResultAggregator } from '../orchestrator/resultAggregator.js';
-import { drainActive, resolveSchedulerConcurrency, startReadyTasks } from '../orchestrator/scheduler.js';
+import { drainActive, resolvePlanConcurrency, startReadyTasks } from '../orchestrator/scheduler.js';
 import { emitRuntimeLog, pollActivitiesOnce } from './supervisor.js';
 
-const DEFAULT_MAX_REPLANS = 2;
+// 0 by default: automatic replans turn evaluator/replanner TEXT into
+// executable pseudo-tasks (no capability, no operation) that stall at 0%
+// and pile up as replan-1/2/3 ghost work — the same disease as the removed
+// text-plan extraction. Failures now end with an honest report; the user
+// (or a stronger model) decides what to do next. Re-enable explicitly with
+// WIKI_MANAGER_REPLANNER_MAX_REPLANS if desired.
+const DEFAULT_MAX_REPLANS = 0;
 
 async function waitForRuntimeActivities(session, startedActivities, { timeoutMs, signal, pollBusy }) {
   const deadline = Date.now() + timeoutMs;
@@ -43,13 +49,36 @@ async function waitForRuntimeActivities(session, startedActivities, { timeoutMs,
   return { ok: false, timedOut: true, completed: tracked };
 }
 
-export async function runRuntimeAgenticLoop(agent, session, initialInput, { signal, timeoutMs, maxTurns, runId, pollBusy, parallelHandoff = false }) {
+// Last chat exchanges (user/assistant) that preceded this run, so the run's
+// LLM knows WHAT was agreed before acting. Long messages are clipped: the
+// context is for grounding, not for re-reading novels.
+// Env knobs (documented in .env.example): every tunable introduced by the
+// grounding/orchestration work is overridable — nothing business-critical
+// is frozen in code.
+export function conversationSeed(session, currentInput, { limit = 12, maxChars = 2000 } = {}) {
+  const conversation = Array.isArray(session.agentProjection?.conversation)
+    ? session.agentProjection.conversation
+    : [];
+  const seed = conversation
+    .filter((message) => ['user', 'assistant'].includes(message?.role) && String(message?.content ?? '').trim())
+    .slice(-limit)
+    .map((message) => ({ role: message.role, content: String(message.content).slice(0, maxChars) }));
+  // The run's own triggering user message is appended by the loop itself —
+  // drop it from the seed to avoid sending it twice.
+  const last = seed.at(-1);
+  if (last && last.role === 'user' && last.content === String(currentInput ?? '').slice(0, maxChars)) seed.pop();
+  return seed;
+}
+
+export async function runRuntimeAgenticLoop(agent, session, initialInput, { signal, timeoutMs, maxTurns, runId, pollBusy, parallelHandoff = false, initialMessages = [] }) {
   return runAgenticLoop(agent, session, initialInput, {
     signal,
     timeoutMs,
     maxTurns,
     runId,
     parallelHandoff,
+    initialMessages,
+    deterministicTerminalSummary: true,
     abortMessage: 'Runtime run cancelled.',
     waitForActivities: (turnSession, startedActivities, waitOptions) =>
       waitForRuntimeActivities(turnSession, startedActivities, { ...waitOptions, pollBusy }),
@@ -78,6 +107,14 @@ export async function runRuntimeAgenticLoop(agent, session, initialInput, { sign
     onActivitiesStarted: ({ activities }) => {
       emitRuntimeLog(session, `agentic-loop: ${activities.length} new activity(s), waiting`);
     },
+    onActivitiesCompleted: ({ summary }) => {
+      emitRuntimeLog(session, `agentic-loop: completed activities:\n${summary}`);
+      dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+        origin: 'runtime',
+        runId,
+        payload: { content: summary || 'Action terminée.' },
+      }));
+    },
     onMaxTurns: ({ maxTurns: totalTurns }) => {
       emitRuntimeLog(session, `agentic-loop: max turns (${totalTurns}) reached`);
     },
@@ -98,6 +135,9 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
 } = {}) {
   let currentInput = initialInput ?? input;
   let replansLeft = Math.max(0, Math.floor(Number(maxReplans) || 0));
+  // Computed ONCE at run start: the pre-run chat. Re-computing inside the
+  // loop would re-ingest this run's own turns and duplicate them.
+  const runConversationSeed = conversationSeed(session, currentInput);
 
   while (true) {
     sanitizeSessionPlanForExecution(session, runId);
@@ -118,6 +158,7 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
         runId,
         pollBusy,
         parallelHandoff: true,
+        initialMessages: runConversationSeed,
       });
     if (result.ok && result.handoff) continue;
     if (!result.ok) {
@@ -203,6 +244,20 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
             continue;
           }
         }
+        // Surface the verdict in the CHAT: the work that ran stays done, the
+        // user sees why the evaluator was unsatisfied and decides — no
+        // self-generated follow-up tasks.
+        dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+          origin: 'runtime',
+          runId,
+          payload: {
+            content: [
+              `Le run est terminé mais l'évaluation le juge incomplet : ${evaluation.reason}`,
+              evaluation.suggestedAction ? `Piste suggérée : ${evaluation.suggestedAction}` : null,
+              'Aucune tâche supplémentaire n\'a été créée automatiquement — dis-moi si tu veux poursuivre.',
+            ].filter(Boolean).join('\n'),
+          },
+        }));
         dispatchAgentEvent(session, createAgentEvent('run_error', {
           origin: 'runtime',
           runId,
@@ -231,7 +286,7 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   maxTurns,
   runId = null,
   pollBusy,
-  concurrency = resolveSchedulerConcurrency(),
+  concurrency = null,
   fragment = null,
   assignmentManager = null,
   attemptManager = null,
@@ -243,7 +298,15 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   dispatcherPollIntervalMs = 250,
 } = {}) {
   if (fragment != null) assertValidatedFragment(fragment);
-  const limit = Math.max(1, Math.floor(Number(concurrency) || 1));
+  const agents = session.agentRegistry?.snapshot?.() ?? session.agentRegistrySnapshot ?? [];
+  const configuredConcurrency = Number(concurrency) > 0
+    ? Number(concurrency)
+    : Number(process.env.WIKI_MANAGER_CAPABILITY_CONCURRENCY || process.env.WIKI_MANAGER_SCHEDULER_CONCURRENCY);
+  const limit = resolvePlanConcurrency({
+    plan: session.headlessPlan ?? [],
+    agents,
+    configured: configuredConcurrency,
+  });
   const active = new Map();
   const attempts = attemptManager ?? createAttemptManager();
   const assigner = assignmentManager ?? createAssignmentManager({ session });
@@ -269,6 +332,15 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   sanitizeSessionPlanForExecution(session, runId);
   ensurePlanProjection(session, runId);
   emitRuntimeLog(session, `scheduler: parallel plan enabled (concurrency ${limit})`);
+  let approvalNoticeSent = false;
+  // Interactive approvals do NOT expire: the user has /approve, "valide
+  // tout", /cancel and /run kill — an arbitrary timer only created mystery
+  // failures. A deadline exists only when explicitly configured (headless
+  // runs, CI) via the session or the env escape hatch.
+  const configuredApprovalWait = Number(session._approvalTimeoutMs) > 0
+    ? Number(session._approvalTimeoutMs)
+    : (Number(process.env.WIKI_MANAGER_APPROVAL_TIMEOUT_MS) > 0 ? Number(process.env.WIKI_MANAGER_APPROVAL_TIMEOUT_MS) : null);
+  const approvalDeadline = configuredApprovalWait ? Date.now() + configuredApprovalWait : Infinity;
 
   try {
     while (true) {
@@ -362,6 +434,44 @@ export async function runRuntimeParallelPlan(agent, session, input, {
           emitRuntimeLog(session, `scheduler: budget exceeded (${exceeded.reason})`);
           return { ok: false, budgetExceeded: true, reason: exceeded.reason, budget: exceeded, completed: sessionActivities(session), failures };
         }
+        const needingApproval = pending.filter((step) => step.requiresApproval === true);
+        if (needingApproval.length > 0) {
+          // The plan is only blocked on a HUMAN decision — wait for it
+          // (bounded) instead of declaring the run stalled. Announce once in
+          // the chat: users cannot approve what they never saw asked.
+          if (!approvalNoticeSent) {
+            approvalNoticeSent = true;
+            dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+              origin: 'runtime',
+              runId,
+              payload: {
+                content: [
+                  `⏸ Approbation requise avant exécution : ${needingApproval.length} tâche(s) mutante(s) en attente.`,
+                  ...needingApproval.slice(0, 5).map((step) => `  - ${step.description ?? step.id}`),
+                  needingApproval.length > 5 ? `  … et ${needingApproval.length - 5} autre(s).` : null,
+                  'Réponds « valide tout » (ou tape /approve) pour lancer, « annule » pour abandonner.',
+                ].filter(Boolean).join('\n'),
+              },
+            }));
+            emitRuntimeLog(session, `scheduler: waiting for approval (${needingApproval.length} task(s))`);
+          }
+          if (Date.now() < approvalDeadline) {
+            await new Promise((resolveDelay) => setTimeout(resolveDelay, 500));
+            continue;
+          }
+          // Configured timeout (headless/CI) reached: say it PLAINLY in the
+          // chat and let run_error clean the plan/activities so nothing
+          // lingers in the panels.
+          emitRuntimeLog(session, 'scheduler: approval wait timed out');
+          dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+            origin: 'runtime',
+            runId,
+            payload: {
+              content: `⏱ Approbation non reçue dans le délai imparti — run arrêté, ${needingApproval.length} tâche(s) annulée(s). Relance la demande quand tu veux.`,
+            },
+          }));
+          return { ok: false, stalled: true, reason: 'awaiting_approval', completed: sessionActivities(session), failures };
+        }
         const reason = pending.every((step) => approvalWaitingStatus(step.status)) ? 'awaiting_approval' : 'no_ready_plan_task';
         emitRuntimeLog(session, `scheduler: stalled (${reason})`);
         return { ok: false, stalled: true, reason, completed: sessionActivities(session), failures };
@@ -1007,7 +1117,7 @@ function formatRecentConversation(session, n = 12) {
     .join('\n');
 }
 
-function resolveMaxReplans(value = process.env.WIKI_MANAGER_REPLANNER_MAX_REPLANS) {
+function resolveMaxReplans(value) {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed)) : DEFAULT_MAX_REPLANS;
 }