@dotdrelle/wiki-manager 0.15.101 → 0.16.0

package/src/orchestrator/dispatcher.js

@@ -2,6 +2,7 @@ import { normalizeActivity, parseJsonText } from '../core/activity.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
 import { loadWorkspaceProfile } from '../core/profile.js';
+import { supportsTemperature } from '../core/llmCapabilities.js';
 import { containerReachableUrl } from '../core/wikiSetup.js';
 import { mapRuntimeEvent } from '../core/runtimeEventAdapter.js';
 import { emitRuntimeLog, pollActivitiesOnce } from '../runtime/supervisor.js';
@@ -259,7 +260,7 @@ async function executeExternalRuntime(task, assignment, {
       model: activeProfileModel(session),
       language: session?.language ?? session?.wikircConfig?.language ?? null,
       mcp: mcpPool,
-      systemPrompt: activeRuntimeSystemPrompt(session, task, assignment),
+      systemPrompt: activeRuntimeSystemPrompt(session, task, assignment, mcpPool),
     });
     runtimeRunId = String(accepted?.runId ?? '');
     if (!runtimeRunId) throw new Error('runtime.execute did not return runId.');
@@ -508,6 +509,10 @@ function activeProfileModel(session) {
     ...(llm.apiKey ? { apiKey: String(llm.apiKey) } : {}),
   };
   for (const key of ['temperature', 'maxTokens', 'topP', 'seed']) {
+    // A gpt-5-class model rejects `temperature`: forwarding the profile's value
+    // would make the external runtime's model call fail (HTTP 400), same as the
+    // manager's own client.
+    if (key === 'temperature' && !supportsTemperature(llm)) continue;
     const value = Number(llm[key]);
     if (Number.isFinite(value)) model[key] = value;
   }
@@ -552,8 +557,8 @@ function isReadOnlyExternalTool(toolName) {
 // The runtime's EYES, per run: the active workspace's wiki MCP (read tools
 // only) PLUS the declared external MCP endpoints that are safe to hand over
 // (connected, no approval-gated tools, not a workspace-mutating server) —
-// typically web search (exa). The allow-list here is the authority: nothing
-// else reaches the runtime.
+// typically a web-search connector. The allow-list here is the authority:
+// nothing else reaches the runtime.
 export function activeProfileMcp(session) {
   const blocks = [];
   const wiki = session?.mcp?.wiki;
@@ -585,8 +590,9 @@ export function activeProfileMcp(session) {
   }
   // External connectors ride along ONLY when the operator declared them safe
   // for the runtime's eyes. A connector added from the serve panel lands here
-  // too — without this, exa was offered in chat but the agentic path
-  // delegated to the gateway and the Deep Agent answered it had no web tools.
+  // too — without this, a web connector was offered in chat but the agentic
+  // path delegated to the gateway and the Deep Agent answered it had no web
+  // tools.
   const EXCLUDED_EXTERNAL_SERVERS = new Set(['cme', 'documents', 'connectors', 'production']);
   for (const [name, entry] of Object.entries(session?.mcp ?? {})) {
     if (!entry?.external || entry.status !== 'connected') continue;
@@ -611,21 +617,56 @@ export function activeProfileMcp(session) {
 // description), the eyes/bouche/mains boundary, the workspace profile and the
 // reply language. Without it, the runtime falls back to deepagents' generic
 // assistant prompt — which is exactly the "upload your project" hallucination.
-function activeRuntimeSystemPrompt(session, task, assignment) {
+// The runtime prompt must describe the pool the same dispatch actually hand
+// over. It used to assert "READ tools only (the workspace wiki)" whatever the
+// pool held, so a run handed an external web-search read tool still answered
+// "je suis limité aux seules sources du wiki" and made zero tool calls
+// (observed on acpi: "cherche sur internet" → agent.answer → refusal, gateway
+// /metrics tools:0). The pool is the authority; the prompt reports it, never
+// denies it.
+function describeRuntimePool(mcpPool) {
+  const blocks = Array.isArray(mcpPool) ? mcpPool : [];
+  const wiki = blocks.find((block) => block?.name === 'wiki');
+  const hasWiki = Boolean(wiki && Array.isArray(wiki.tools) && wiki.tools.length > 0);
+  const external = blocks
+    .filter((block) => block && block.name !== 'wiki' && Array.isArray(block.tools) && block.tools.length > 0)
+    .map((block) => ({
+      name: String(block.name),
+      tools: block.tools.map((tool) => `${block.name}__${String(tool)}`),
+    }));
+  return { hasWiki, external };
+}
+
+export function activeRuntimeSystemPrompt(session, task, assignment, mcpPool = null) {
   const capability = assignment?.capability ?? null;
   const description = String(capability?.description ?? '').trim();
   const language = session?.language ?? session?.wikircConfig?.language ?? null;
   const profile = loadWorkspaceProfile(session?.workspacePath);
+  const { hasWiki, external } = describeRuntimePool(mcpPool);
+  const externalTools = external.flatMap((block) => block.tools);
+  // Wiki first, then the declared external read tools. A run that has a web
+  // search tool must not refuse with "I cannot search the internet": that
+  // refusal is exactly the symptom this line exists to prevent.
+  const vision = externalTools.length > 0
+    ? [
+        `Beyond the wiki you also have these READ tools: ${externalTools.join(', ')}.`,
+        hasWiki
+          ? 'Search the workspace wiki FIRST; then use those external/web read tools for current, public or out-of-workspace facts the wiki does not cover.'
+          : 'Use those external/web read tools for facts the workspace does not cover.',
+        'Never answer that you cannot search the internet or that you are limited to the wiki: when such a tool is listed here, call it.',
+      ].join(' ')
+    : null;
   return [
     'You are the agentic analysis engine of a knowledge workspace (wikiLLM), executed behind the manager Donna.',
     `Execute exactly ONE capability: ${task?.requiredCapability ?? 'unknown'}${description ? ` — ${description}` : ''}.`,
     `Operation: ${task?.operation ?? 'run'}.`,
-    'Boundary: you have READ tools only (the workspace wiki). You never modify the workspace — structural changes are proposals you return in your final answer (a planExpansionRequest), the manager integrates them under human approval. Side-effects on the outside world are gated by approval.',
+    'Boundary: you have READ tools only (the tools this run makes available, listed in your pool). You never modify the workspace — structural changes are proposals you return in your final answer (a planExpansionRequest), the manager integrates them under human approval. Side-effects on the outside world are gated by approval.',
+    vision,
     'Ground every claim in what the read tools return. Never invent pages, names, facts, jobs or results.',
     'Tool discipline: discover real page paths with the list/search tools BEFORE reading. Never guess a path — a read refused for "path not allowed" means the path was invented, so list/search first, then read exactly what exists.',
     ...(language ? [`Reply in the workspace language: ${language}.`] : []),
     ...(profile ? [`Workspace preferences — apply them to every reply:\n${profile}`] : []),
-  ].join('\n');
+  ].filter(Boolean).join('\n');
 }
 
 function dispatchTaskActivity(session, task, assignment, jobId, statusTool, runId) {

package/src/orchestrator/dispatcher.test.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { activeProfileMcp, createDispatcher, normalizeTaskError, RUNTIME_SHUTDOWN_ABORT_REASON } from './dispatcher.js';
+import { activeProfileMcp, activeRuntimeSystemPrompt, createDispatcher, normalizeTaskError, RUNTIME_SHUTDOWN_ABORT_REASON } from './dispatcher.js';
 
 test('activeProfileMcp forwards only the read-only wiki tools to the external runtime', () => {
   const session = {
@@ -114,6 +114,38 @@ test('activeProfileMcp rewrites loopback URLs for the container the runtime runs
   assert.equal(pool.find((block) => block.name === 'hosted').url, 'https://mcp.exa.ai/mcp');
 });
 
+test('activeRuntimeSystemPrompt names the declared web tools and forbids "cannot search the internet"', () => {
+  const session = { workspace: 'acpi', language: 'fr-FR' };
+  const pool = [
+    { name: 'wiki', tools: ['wiki_read_page', 'wiki_search_context'] },
+    { name: 'exa', tools: ['web_search_exa', 'web_fetch_exa'] },
+  ];
+  const prompt = activeRuntimeSystemPrompt(
+    session,
+    { requiredCapability: 'agent.answer', operation: 'run' },
+    { capability: { description: 'wiki and web research' } },
+    pool,
+  );
+  assert.match(prompt, /exa__web_search_exa/);
+  assert.match(prompt, /exa__web_fetch_exa/);
+  assert.match(prompt, /wiki FIRST/i);
+  assert.match(prompt, /cannot search the internet/i);
+  assert.match(prompt, /agent\.answer/);
+});
+
+test('activeRuntimeSystemPrompt stays wiki-only when the pool declares no external read tools', () => {
+  const session = { workspace: 'acpi' };
+  const prompt = activeRuntimeSystemPrompt(
+    session,
+    { requiredCapability: 'agent.review' },
+    { capability: {} },
+    [{ name: 'wiki', tools: ['wiki_read_page'] }],
+  );
+  assert.doesNotMatch(prompt, /exa__/);
+  assert.doesNotMatch(prompt, /cannot search the internet/i);
+  assert.match(prompt, /the tools this run makes available/);
+});
+
 test('dispatcher returns a retryable logical failure when agent_execute reports workspace_busy', async () => {
   const session = {
     workspace: 'test',

package/src/orchestrator/lockManager.js

@@ -1,27 +1,62 @@
-export function createLockManager({ locks = new Set() } = {}) {
+/*
+ One registry per WORKSPACE, not per run.
+
+ The registry used to be created by each run's attemptManager, so its locks
+ only ever excluded tasks of the same run. That was harmless while a
+ workspace ran one run at a time, but anything acting beside a run — a
+ direct write from a chat turn, a second run — held nothing the first one
+ could see. `workspaceLockRegistry` hangs one registry on the workspace
+ session; every run and every direct action shares it
+ (plan-demandes-pendant-run.md, lot 2). `owners` records who holds each lock
+ so a wait can name its holder instead of stalling in silence.
+*/
+export function workspaceLockRegistry(session) {
+  if (!session) return { locks: new Set(), owners: new Map() };
+  session._workspaceLocks ??= { locks: new Set(), owners: new Map() };
+  return session._workspaceLocks;
+}
+
+export function createLockManager({ locks = new Set(), owners = new Map() } = {}) {
   return {
     canAcquire(taskOrLocks) {
       return locksFor(taskOrLocks).every((lock) => !locks.has(lock));
     },
-    acquire(taskOrLocks) {
+    acquire(taskOrLocks, owner = null) {
       const lockNames = locksFor(taskOrLocks);
       if (lockNames.some((lock) => locks.has(lock))) return null;
-      for (const lock of lockNames) locks.add(lock);
+      for (const lock of lockNames) {
+        locks.add(lock);
+        if (owner != null) owners.set(lock, owner);
+      }
       let released = false;
       return {
         locks: lockNames,
         release() {
           if (released) return;
           released = true;
-          for (const lock of lockNames) locks.delete(lock);
+          for (const lock of lockNames) {
+            locks.delete(lock);
+            owners.delete(lock);
+          }
         },
       };
     },
     release(taskOrLocks) {
-      for (const lock of locksFor(taskOrLocks)) locks.delete(lock);
+      for (const lock of locksFor(taskOrLocks)) {
+        locks.delete(lock);
+        owners.delete(lock);
+      }
+    },
+    // Who holds the locks a task would need: [{ lock, owner }], owner null
+    // when the holder did not name itself.
+    holders(taskOrLocks) {
+      return locksFor(taskOrLocks)
+        .filter((lock) => locks.has(lock))
+        .map((lock) => ({ lock, owner: owners.get(lock) ?? null }));
     },
     clear() {
       locks.clear();
+      owners.clear();
     },
     snapshot() {
       return [...locks].sort();

package/src/orchestrator/resultAggregator.js

@@ -78,6 +78,13 @@ export async function accept(result, {
       taskId,
       payload: { message: `agent-proposal: could not persist the worktree proposal for ${taskId}: ${worktreePersisted.error}` },
     })));
+  } else if (worktreePersisted.empty) {
+    persistDispatch(store, dispatchAgentEvent(session, createAgentEvent('runtime_log', {
+      origin: 'result_aggregator',
+      runId,
+      taskId,
+      payload: { message: `⚠ agent-proposal: ${taskId} wrote no file on its branch — nothing to review; the corrections its report describes were not written` },
+    })));
   } else if (worktreePersisted.path) {
     persistDispatch(store, dispatchAgentEvent(session, createAgentEvent('runtime_log', {
       origin: 'result_aggregator',
@@ -315,7 +322,11 @@ function persistWorktreeProposal(session, result, { runId, taskId }) {
     ?? result?.worktreeProposal;
   if (!proposal || typeof proposal !== 'object') return { path: null };
   const changes = Array.isArray(proposal.changes) ? proposal.changes : [];
-  if (changes.length === 0) return { path: null };
+  // A curation that wrote nothing has nothing to review — but it must SAY so.
+  // Returning silently here left the review page empty while the run was
+  // reported a success, its report describing corrections on a branch that
+  // held none (observed on acpi).
+  if (changes.length === 0) return { path: null, empty: true };
   const workspacePath = session?.workspacePath;
   if (!workspacePath || typeof workspacePath !== 'string') {
     return { error: 'no workspace path on the session — the proposal stays in the run result only' };

package/src/orchestrator/resultAggregator.test.js

@@ -409,3 +409,32 @@ test('a gateway worktree proposal (rawStatus shape) is persisted for review', as
     rmSync(workspacePath, { recursive: true, force: true });
   }
 });
+
+test('a curation that wrote no file says so instead of vanishing from the review page', async () => {
+  // Observed on acpi: the Redactor described its corrections in prose on a
+  // branch it invented, wrote nothing, and the run was reported a success
+  // while /agent-proposals stayed empty with no word anywhere.
+  const workspacePath = mkdtempSync(join(tmpdir(), 'worktree-proposal-'));
+  const session = { agentEvents: [], activities: {}, workspace: 'docs', workspacePath, headlessPlan: [] };
+  try {
+    await accept({
+      ok: true,
+      taskId: 't-curate',
+      status: 'completed',
+      outputRefs: [],
+      rawStatus: {
+        runId: 'gateway-1',
+        status: 'completed',
+        result: { status: 'completed', content: 'report', worktreeProposal: { branch: 'agent/gateway-1', changedFiles: [], changes: [], diff: '' } },
+      },
+    }, {
+      session,
+      runId: 'run-curate',
+      task: { id: 't-curate', requiredCapability: 'agent.curate', operation: 'run' },
+    });
+    assert.equal(existsSync(join(workspacePath, '.wiki', 'agent-proposals')), false);
+    assert.ok(session.agentEvents.some((event) => /wrote no file on its branch — nothing to review/.test(String(event.payload?.message ?? ''))));
+  } finally {
+    rmSync(workspacePath, { recursive: true, force: true });
+  }
+});

package/src/runtime/controlClassify.test.js

@@ -15,10 +15,11 @@ test('a bare confirmation during a run is a status check', async () => {
   }
 });
 
-test('a plan change that merely opens on a yes is still a plan change', async () => {
+test('a plan change that merely opens on a yes reaches the model, not the status branch', async () => {
   const result = await classifyControlMessage(
     'oui, ajoute une étape de polish après le build',
     running,
+    { llm: { complete: async () => 'plan_change' } },
   );
   assert.equal(result.kind, 'modify_run');
 });
@@ -29,3 +30,86 @@ test('a new task that opens on a yes reaches the model classifier, not the statu
   });
   assert.equal(result.kind, 'enqueue_run');
 });
+
+// The empty-chat "Curate the wiki" tile sends free-text prose. While a run was
+// active, its "pages that disagree or repeat each other" matched the
+// deterministic modify_run keyword "each" and the curation became an invisible
+// plan patch instead of a queued run.
+test('a curation objective during a run is queued, never an invisible plan patch', async () => {
+  const objective =
+    'Curate the wiki: find duplicate pages, pages that disagree or repeat each other, '
+    + 'outdated or superseded pages, and claims with no cited source, then write the '
+    + 'corrections on a dedicated branch.';
+  const result = await classifyControlMessage(objective, running, {
+    llm: { complete: async () => 'action' },
+  });
+  assert.equal(result.kind, 'enqueue_run');
+});
+
+test('a question about curation stays read-only', async () => {
+  const result = await classifyControlMessage('explain how curation works', running, {
+    llm: { complete: async () => 'question' },
+  });
+  assert.equal(result.kind, 'converse');
+});
+
+test('a genuine plan change is classified as modify_run by the model', async () => {
+  const result = await classifyControlMessage('ajoute une étape de polish après le build', running, {
+    llm: { complete: async () => 'plan_change' },
+  });
+  assert.equal(result.kind, 'modify_run');
+});
+
+// Measured 2026-09-25 (plan-demandes-pendant-run.md §2): keywords inside a
+// sentence decided before the model, so questions typed during an ingest were
+// answered with the run status, turned into patches of the running plan, or
+// cancelled the run. No keyword inside a sentence decides any more.
+test('a keyword inside a question never decides the triage', async () => {
+  const asked = [];
+  const llm = { complete: async ({ input }) => { asked.push(input); return 'question'; } };
+  for (const question of [
+    "montre-moi ce que dit le wiki sur l'option A",
+    'explique la différence entre les options A et B',
+    'cherche les pages qui parlent du plan de charge',
+    'que se passe-t-il après la validation dans SISBA ?',
+    "quand est-ce qu'on stop le support de CDPOM ?",
+    'que dit le wiki sur la curation des données ?',
+    "qu'est-ce qu'on fait ensuite dans le projet ?",
+  ]) {
+    const result = await classifyControlMessage(question, running, { llm });
+    assert.equal(result.kind, 'converse', question);
+  }
+  assert.equal(asked.length, 7, 'every one of them reached the model');
+});
+
+test('the model categories map onto the control kinds', async () => {
+  for (const [word, kind] of [
+    ['question', 'converse'], ['status', 'observe'], ['action', 'enqueue_run'],
+    ['plan_change', 'modify_run'], ['cancel', 'cancel'], ['Action.', 'enqueue_run'],
+  ]) {
+    const result = await classifyControlMessage('modifie la page option-a', running, {
+      llm: { complete: async () => word },
+    });
+    assert.equal(result.kind, kind, word);
+  }
+});
+
+test('only a whole-message command is decided without the model', async () => {
+  const cases = [
+    ['stop', 'cancel'], ['annule', 'cancel'], ['arrête tout !', 'cancel'], ['cancel the run', 'cancel'],
+    ["annule l'ingestion", 'cancel'], ['status', 'observe'], ['où en est-on ?', 'observe'],
+    ['logs', 'observe'], ['quel est le statut du run ?', 'observe'],
+    ["mets en file l'export", 'enqueue_run'], ['lance le build après ce run', 'enqueue_run'],
+  ];
+  for (const [input, kind] of cases) {
+    const result = await classifyControlMessage(input, running);
+    assert.equal(result.kind, kind, input);
+  }
+});
+
+test('without a model every other message is read-only conversation', async () => {
+  for (const input of ['curate the wiki', 'modifie la page option-a', "quand est-ce qu'on stop le support ?"]) {
+    const result = await classifyControlMessage(input, running);
+    assert.equal(result.kind, 'converse', input);
+  }
+});

package/src/runtime/conversationCompact.js

@@ -0,0 +1,39 @@
+import { emitRuntimeLog } from './supervisor.js';
+
+const CONVERSATION_SUMMARY_TIMEOUT_MS = 20_000;
+const CONVERSATION_SUMMARY_MAX_INPUT_CHARS = 8_000;
+
+/*
+ A compact does not just cut older turns from conversationSeed — it replaces
+ them with a short rolling summary, so a decision made 20 messages ago is not
+ gone from Donna's grounding entirely, only condensed. Best-effort: no LLM
+ configured, an empty reply, or a call failure all fall back to keeping
+ whatever summary already existed (never worse than before this compact),
+ the same deterministic-under-failure shape as generateControlAcknowledgment.
+ */
+export async function summarizeCompactedConversation(session, { previousSummary, segment }) {
+  const llm = session?.llm;
+  const transcript = (Array.isArray(segment) ? segment : [])
+    .filter((message) => ['user', 'assistant'].includes(message?.role) && String(message?.content ?? '').trim())
+    .map((message) => `${message.role === 'user' ? 'User' : 'Assistant'}: ${String(message.content).trim()}`)
+    .join('\n')
+    .slice(0, CONVERSATION_SUMMARY_MAX_INPUT_CHARS);
+  if (!transcript) return previousSummary || null;
+  if (!(llm && typeof llm.complete === 'function')) return previousSummary || null;
+  try {
+    const reply = await llm.complete({
+      system: 'You maintain a compact working memory for Donna, a workspace assistant. You are shown an optional PREVIOUS SUMMARY and a NEW SEGMENT of conversation about to leave the assistant\'s context window. Write ONE updated summary that preserves the facts, decisions, open questions and user preferences that still matter for future turns. Be concise: well under 200 words. Return only the summary text — no preamble, no meta-commentary, no headings.',
+      input: [
+        previousSummary ? `PREVIOUS SUMMARY:\n${previousSummary}` : null,
+        `NEW SEGMENT:\n${transcript}`,
+      ].filter(Boolean).join('\n\n'),
+      signal: AbortSignal.timeout(CONVERSATION_SUMMARY_TIMEOUT_MS),
+    });
+    const text = String(reply ?? '').trim();
+    if (text) return text;
+    emitRuntimeLog(session, 'conversation-compact: LLM returned an empty summary, keeping the previous one');
+  } catch (err) {
+    emitRuntimeLog(session, `conversation-compact: summary LLM call failed, keeping the previous summary — ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return previousSummary || null;
+}

package/src/runtime/conversationCompaction.test.js

@@ -0,0 +1,72 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { conversationCompactionPlan, compactionNoteForDonna, conversationSeed } from './runner.js';
+import { createAgentEvent, reduceAgentEvents } from '../core/agentEvents.js';
+
+const exchange = (n) => [
+  { role: 'user', content: `question ${n}` },
+  { role: 'assistant', content: `réponse ${n}` },
+];
+
+test('no compaction while the whole conversation fits the seed window', () => {
+  const conversation = [1, 2, 3].flatMap(exchange);
+  assert.equal(conversationCompactionPlan({ conversation }), null);
+});
+
+test('a message about to leave the window triggers a compaction that keeps the last exchanges', () => {
+  const conversation = [1, 2, 3, 4, 5, 6, 7].flatMap(exchange); // 14 > 12
+  const plan = conversationCompactionPlan({ conversation });
+  assert.equal(plan.reason, 'window');
+  assert.equal(plan.keepLast, 6);
+  assert.equal(plan.segment.length, 8);
+  assert.equal(plan.segment.at(-1).content, 'réponse 4');
+});
+
+test('a small-context profile compacts on the budget before the window fills', () => {
+  const conversation = [1, 2].flatMap(exchange).map((m) => ({ ...m, content: `${m.content} ${'x'.repeat(900)}` }));
+  assert.equal(conversationCompactionPlan({ conversation }, { budgetChars: 100000 }), null);
+  const plan = conversationCompactionPlan({ conversation }, { budgetChars: 4000, keepLast: 2 });
+  assert.equal(plan.reason, 'budget');
+  assert.equal(plan.segment.length, 2);
+});
+
+test('the compact boundary keeps the last exchanges verbatim in the seed', () => {
+  const events = [1, 2, 3, 4, 5, 6, 7].flatMap((n) => [
+    createAgentEvent('user_message', { payload: { content: `question ${n}` } }),
+    createAgentEvent('assistant_message', { payload: { content: `réponse ${n}` } }),
+  ]);
+  events.push(createAgentEvent('conversation_reset', { payload: { summary: 'Résumé 1-4.', keepLast: 6, automatic: true } }));
+  const projection = reduceAgentEvents(events);
+  const seed = conversationSeed({ agentProjection: projection }, 'rajoute la liste');
+  assert.match(seed[0].content, /Résumé 1-4\./);
+  assert.deepEqual(seed.slice(1).map((m) => m.content), ['question 5', 'réponse 5', 'question 6', 'réponse 6', 'question 7', 'réponse 7']);
+  assert.equal(conversationCompactionPlan(projection), null, 'nothing more to compact');
+});
+
+test('Donna is the one who tells the user, in the reply language', () => {
+  const note = compactionNoteForDonna(8);
+  assert.match(note, /8 oldest messages/);
+  assert.match(note, /tell them so in one short sentence, in the reply language/);
+});
+
+test('the compact cut never separates a question from its answer', () => {
+  // Observed on acpi: 6 raw messages kept, the cut fell between the user's
+  // question and Donna's answer, and the summary dropped the question.
+  const conversation = [
+    ...[1, 2, 3, 4, 5].flatMap(exchange),
+    { role: 'user', content: 'comment utiliser https://github.com/gregmos/PII-Shield' },
+    { role: 'assistant', content: 'Le wiki ne décrit pas PII-Shield.' },
+    { role: 'user', content: 'cherche sur internet' },
+    { role: 'user', content: 'cherche sur internet' },
+    { role: 'assistant', content: 'Lancer la recherche.' },
+    { role: 'assistant', content: 'Je suis limité au wiki.' },
+    { role: 'assistant', content: 'Le plan est terminé.' },
+  ];
+  const plan = conversationCompactionPlan({ conversation });
+  assert.equal(plan.segment.at(-1).content, 'réponse 5');
+  assert.equal(plan.keepLast, 7, 'moved back to the question');
+  const events = conversation.map((m) => createAgentEvent(m.role === 'user' ? 'user_message' : 'assistant_message', { payload: { content: m.content } }));
+  events.push(createAgentEvent('conversation_reset', { payload: { summary: 'Résumé.', keepLast: plan.keepLast } }));
+  const seed = conversationSeed({ agentProjection: reduceAgentEvents(events) }, 'x');
+  assert.match(seed[1].content, /PII-Shield/);
+});

package/src/runtime/runner.e2e.test.js

@@ -136,3 +136,52 @@ test('multi-agent scheduler beats sequential on 2 independent build tasks by the
     `expected multi-agent duration (${parallelDurationMs}ms) under ${MAX_PARALLEL_TO_SEQUENTIAL_RATIO * 100}% of sequential duration (${sequentialDurationMs}ms, threshold ${thresholdMs}ms)`,
   );
 });
+
+// plan-demandes-pendant-run.md, lot 2: the lock registry is the WORKSPACE's.
+// A task whose lock another run (or a direct write) holds must wait for it and
+// say so — before, the run declared itself stalled and stopped.
+test('a task waits for a workspace lock held by another run, then runs', async () => {
+  const { workspaceLockRegistry, createLockManager } = await import('../orchestrator/lockManager.js');
+  const session = {
+    workspace: 'demo-workspace',
+    activities: {},
+    agentEvents: [],
+    headlessPlan: [{ ...plannedBuildTask(1, 'template-a'), locks: ['workspace-write'] }],
+    mcp: { production: { status: 'connected', tools: [{ name: 'agent_execute' }, { name: 'agent_status' }, { name: 'agent_cancel' }] } },
+    agentRegistrySnapshot: [productionAgent()],
+    wikircConfig: { capabilityRouting: {} },
+  };
+  const registry = workspaceLockRegistry(session);
+  const other = createLockManager(registry).acquire(['workspace-write'], 'run-ingest');
+  const RELEASE_AFTER_MS = 200;
+  const releasedAt = Date.now() + RELEASE_AFTER_MS;
+  setTimeout(() => other.release(), RELEASE_AFTER_MS);
+  let executedAt = null;
+  const callTool = async (_mcp, _serverName, toolName, args) => {
+    if (toolName === 'agent_execute') {
+      executedAt = Date.now();
+      return toolResult({ accepted: true, jobId: `job-${args.taskId}`, status: 'queued' });
+    }
+    if (toolName === 'agent_status') {
+      return toolResult({ jobId: args.jobId, status: 'done', result: { status: 'succeeded', outputRefs: [] } });
+    }
+    if (toolName === 'agent_cancel') return toolResult({ ok: true });
+    throw new Error(`unexpected tool: ${toolName}`);
+  };
+  const result = await runRuntimeParallelPlan({ invoke: async () => assert.fail('child Donna loop must not run') }, session, 'Build', {
+    runId: 'run-build',
+    timeoutMs: 10_000,
+    maxTurns: 1,
+    callTool,
+    dispatcherPollIntervalMs: 5,
+  });
+  assert.equal(result.ok, true, JSON.stringify(result));
+  assert.ok(executedAt >= releasedAt - 5, 'the task started only once the other run released the lock');
+  const waits = session.agentEvents
+    .filter((event) => event.type === 'runtime_log')
+    .map((event) => String(event.payload?.message ?? ''))
+    .filter((message) => message.includes('waiting for workspace lock'));
+  assert.equal(waits.length, 1, 'announced once, not on every poll');
+  assert.match(waits[0], /workspace-write \(held by run-ingest\)/);
+  assert.deepEqual(registry.locks.size, 0, 'nothing left held once both are done');
+});

package/src/runtime/runner.js

@@ -5,6 +5,7 @@ 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';
+import { workspaceLockRegistry } from '../orchestrator/lockManager.js';
 import { createBudgetManager, BudgetExceededError } from '../orchestrator/budgetManager.js';
 import { createDispatcher } from '../orchestrator/dispatcher.js';
 import { approvalCovered, approvalRequestForTask } from '../orchestrator/approvalPolicy.js';
@@ -86,6 +87,43 @@ export function conversationSeed(session, currentInput, { limit = 12, maxChars =
   return seed;
 }
 
+/**
+ * Decides whether the conversation memory must be compacted before a turn.
+ *
+ * `conversationSeed` keeps the last `limit` messages: anything older left
+ * Donna's context WITHOUT a summary and without a word — silence is the bug.
+ * So a compaction is due as soon as a message would fall out of that window,
+ * or when the seed alone takes more than a quarter of the model's input
+ * budget (a small-context profile). The last `keepLast` messages stay
+ * verbatim: a follow-up needs the previous answer word for word.
+ * Pure: returns the segment to summarize, or null.
+ */
+export function conversationCompactionPlan(projection, { limit = 12, keepLast = 6, maxChars = 2000, budgetChars = null } = {}) {
+  const conversation = Array.isArray(projection?.conversation) ? projection.conversation : [];
+  const seedStart = Math.max(0, Number(projection?.conversationSeedStart) || 0);
+  const live = conversation.slice(seedStart)
+    .filter((message) => ['user', 'assistant'].includes(message?.role) && String(message?.content ?? '').trim());
+  const seedChars = live.slice(-limit).reduce((total, message) => total + Math.min(maxChars, String(message.content).length), 0)
+    + String(projection?.conversationSummary ?? '').length;
+  const overflow = live.length > limit;
+  const heavy = Number(budgetChars) > 0 && seedChars > Number(budgetChars) / 4;
+  if (!overflow && !heavy) return null;
+  // The cut never splits an exchange: it moves back to the user message that
+  // opened it. Observed: a cut between « comment utiliser <url> » and its
+  // answer sent the question into the summary, which dropped it — Donna then
+  // held an answer without its question and asked what to search for.
+  let cut = Math.max(seedStart, conversation.length - keepLast);
+  while (cut > seedStart && conversation[cut]?.role !== 'user') cut -= 1;
+  const segment = conversation.slice(seedStart, cut);
+  if (!segment.some((message) => ['user', 'assistant'].includes(message?.role) && String(message?.content ?? '').trim())) return null;
+  return { segment, keepLast: conversation.length - cut, reason: overflow ? 'window' : 'budget', previousSummary: projection?.conversationSummary ?? null };
+}
+
+/** What Donna is told after an automatic compaction — she says it, not the system. */
+export function compactionNoteForDonna(count) {
+  return `[Memory note for Donna — not written by the user] The ${count} oldest messages of this conversation were just condensed automatically into the summary above, to stay within the model's context; the messages below are verbatim. After answering the user's next question, tell them so in one short sentence, in the reply language.`;
+}
+
 export async function runRuntimeAgenticLoop(agent, session, initialInput, { signal, timeoutMs, maxTurns, runId, pollBusy, parallelHandoff = false, initialMessages = [] }) {
   return runAgenticLoop(agent, session, initialInput, {
     signal,
@@ -419,7 +457,15 @@ export async function runRuntimeParallelPlan(agent, session, input, {
     cappedByCeiling: concurrencyDetail.cappedByCeiling,
   };
   const active = new Map();
-  const attempts = attemptManager ?? createAttemptManager();
+  // The workspace's lock registry, shared with every other run and direct
+  // action of this workspace; this run holds its locks under its own id.
+  const lockRegistry = workspaceLockRegistry(session);
+  const attempts = attemptManager ?? createAttemptManager({
+    locks: lockRegistry.locks,
+    owners: lockRegistry.owners,
+    owner: runId ?? 'run',
+  });
+  let announcedLockWait = '';
   const assigner = assignmentManager ?? createAssignmentManager({ session });
   const executor = dispatcher ?? createDispatcher({
     session,
@@ -648,6 +694,24 @@ export async function runRuntimeParallelPlan(agent, session, input, {
           // notamment derrière une barrière de groupe désormais terminale.
           continue;
         }
+        // A task whose only blocker is a lock held by ANOTHER run or a direct
+        // action waits for it: that holder will release it, so this is a
+        // queue, not a stall. Said once per change of holder, never silently.
+        const lockWaits = (session.headlessPlan ?? [])
+          .filter((step) => pendingSchedulerStatus(step.status))
+          .map((step) => ({ step, holders: attempts.foreignHolders?.(step) ?? [] }))
+          .filter((entry) => entry.holders.length > 0);
+        if (lockWaits.length > 0) {
+          const held = [...new Map(lockWaits.flatMap((entry) => entry.holders)
+            .map((holder) => [holder.lock, holder])).values()];
+          const summary = held.map((holder) => `${holder.lock} (held by ${holder.owner ?? 'another action'})`).join(', ');
+          if (summary !== announcedLockWait) {
+            announcedLockWait = summary;
+            emitRuntimeLog(session, `scheduler: waiting for workspace lock(s) — ${summary}; ${lockWaits.length} task(s) queued behind`);
+          }
+          await new Promise((resolveDelay) => setTimeout(resolveDelay, 500));
+          continue;
+        }
         // Any genuine approval-only block returned above. Remaining tasks are
         // unschedulable for another reason.
         const reason = 'no_ready_plan_task';