@dotdrelle/wiki-manager 0.12.12 → 0.14.0

package/src/runtime/server.js

@@ -15,6 +15,7 @@ export function startRuntimeServer({
   session = null,
   getContext,
   run,
+  delegate,
   cancel,
   resume,
   approve,
@@ -271,6 +272,36 @@ export function startRuntimeServer({
         }
         return;
       }
+      if (request.method === 'POST' && url.pathname === '/delegate') {
+        const { body, context } = await resolveBodyContext(request, url);
+        const objective = String(body.objective ?? '').trim();
+        if (!objective) {
+          sendJson(response, 400, { error: 'Missing objective.' });
+          return;
+        }
+        if (context.running) {
+          sendJson(response, 409, { error: 'A runtime run is already active.' });
+          return;
+        }
+        if (typeof delegate !== 'function') {
+          sendJson(response, 501, { error: 'Runtime delegation is unavailable.' });
+          return;
+        }
+        try {
+          const prepared = await delegate(context, { objective, workspace: body.workspace ?? context.workspace ?? null });
+          const started = startRuntimeRun(context, {
+            input: objective,
+            workspace: body.workspace ?? context.workspace ?? null,
+            preparedDelegation: prepared,
+            evaluate: false,
+          }, { waitForPlan: true });
+          await started.ready;
+          sendJson(response, 202, { accepted: true, runId: started.runId, workspace: started.workspace, delegation: prepared.summary ?? null });
+        } catch (err) {
+          sendJson(response, 422, { error: err instanceof Error ? err.message : String(err) });
+        }
+        return;
+      }
       if (request.method === 'POST' && url.pathname === '/cancel') {
         const workspace = workspaceFromUrl(url);
         const context = await resolveContext({ workspace });
@@ -391,14 +422,22 @@ export function startRuntimeServer({
     return { killed: true, workspace: targetWorkspace, runId: targetRunId, runs, tasks, queued };
   }
 
-  function startRuntimeRun(context, body, { controlItemId = null } = {}) {
+  function startRuntimeRun(context, body, { controlItemId = null, waitForPlan = false } = {}) {
     const runId = randomUUID();
     const runWorkspace = context.workspace ?? body.workspace ?? null;
     context.running = true;
     context.currentAbortController = new AbortController();
     context.currentRunId = runId;
     context.currentRunWorkspace = runWorkspace;
-    const runBody = { ...body, workspace: runWorkspace, runId };
+    let resolveReady;
+    let rejectReady;
+    const ready = waitForPlan ? new Promise((resolve, reject) => { resolveReady = resolve; rejectReady = reject; }) : null;
+    const runBody = {
+      ...body,
+      workspace: runWorkspace,
+      runId,
+      ...(waitForPlan ? { _planReady: { resolve: resolveReady, reject: rejectReady } } : {}),
+    };
     if (controlItemId) {
       dispatchAgentEvent(context.session, createAgentEvent('control_started', {
         origin: 'runtime',
@@ -410,6 +449,7 @@ export function startRuntimeServer({
     const runPromise = run(context, runBody, { signal: context.currentAbortController.signal, runId });
     runPromise
       .catch((err) => {
+        rejectReady?.(err);
         context.session?._onRuntimeError?.(err);
       })
       .finally(() => {
@@ -420,7 +460,7 @@ export function startRuntimeServer({
         publishState(runWorkspace, context);
         void startNextControlRequest(context);
       });
-    return { accepted: true, runId, workspace: runWorkspace };
+    return { accepted: true, runId, workspace: runWorkspace, ...(ready ? { ready } : {}) };
   }
 
   function startNextControlRequest(context) {

package/src/runtime/supervisor.js

@@ -119,7 +119,10 @@ export async function pollActivitiesOnce(session, {
         const retry = progress.retryAt
           ? `retry ${progress.retryAt}`
           : (progress.waitMs ? `wait ${progress.waitMs}ms` : null);
-        const progressKey = `${polledActivity.status}:${Number.isFinite(percent) ? Math.round(percent) : ''}:${detail}:${batch ?? ''}:${lastEvent ?? ''}:${retry ?? ''}`;
+        // retryAt/waitMs are scheduling metadata and may be recomputed on every
+        // status poll. They must remain visible in the first log line, but must
+        // not turn an unchanged quota/backoff state into a new trace event.
+        const progressKey = `${polledActivity.status}:${Number.isFinite(percent) ? Math.round(percent) : ''}:${detail}:${batch ?? ''}:${lastEvent ?? ''}`;
         session._activityLogKeys ??= {};
         if (session._activityLogKeys[key] !== progressKey) {
           session._activityLogKeys[key] = progressKey;

package/src/runtime/supervisor.test.js

@@ -41,6 +41,55 @@ test('pollActivitiesOnce updates activity through the event reducer', async () =
   assert.ok(session.agentProjection.logs.some((line) => line.includes('activity:')));
 });
 
+test('pollActivitiesOnce does not repeat an unchanged retry state when retryAt moves', async () => {
+  const session = {
+    mcp: { production: { status: 'connected' } },
+    activities: {},
+    headlessPlan: null,
+    jobQueue: [],
+  };
+  dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
+    payload: {
+      activity: {
+        id: 'job-quota',
+        source: 'production',
+        label: 'Production · ingest',
+        status: 'running',
+        poll: { server: 'production', tool: 'production_job_status', args: { jobId: 'job-quota' }, intervalMs: 0 },
+      },
+    },
+  }));
+
+  let poll = 0;
+  const callTool = async () => {
+    poll += 1;
+    return {
+      content: [{ type: 'text', text: JSON.stringify({
+        _activity: {
+          id: 'job-quota',
+          source: 'production',
+          label: 'Production · ingest',
+          status: 'running',
+          terminal: false,
+          progress: {
+            percent: 15,
+            detail: 'LLM quota wait',
+            lastEvent: 'llm:rate-limit-wait',
+            retryAt: `2026-07-10T20:31:5${poll}.000Z`,
+          },
+        },
+      }) }],
+    };
+  };
+
+  await pollActivitiesOnce(session, { callTool });
+  await pollActivitiesOnce(session, { callTool });
+
+  const lines = session.agentProjection.logs.filter((line) => line.includes('activity: Production · ingest'));
+  assert.equal(lines.length, 1);
+  assert.match(lines[0], /retry 2026-07-10T20:31:51\.000Z/);
+});
+
 test('pollActivitiesOnce retries transient MCP poll failures', async () => {
   const originalFetch = globalThis.fetch;
   let attempts = 0;

package/src/shell/repl.js

@@ -5,7 +5,7 @@ import { execFileSync } from 'node:child_process';
 import { stdin as input, stdout as output } from 'node:process';
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
-import { buildAgentSystemPrompt, classifyAgentInput, formatLlmUnavailableMessage } from '../agent/graph.js';
+import { buildAgentSystemPrompt, formatLlmUnavailableMessage } from '../agent/graph.js';
 import { handleSlashCommand } from '../commands/slash.js';
 import { serviceDescription, serviceNames as composeServiceNames } from '../core/compose.js';
 import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
@@ -292,6 +292,7 @@ function buildDirectChatSystemPrompt(session) {
   return [
     'You are Donna, the llm-wiki-manager chat assistant.',
     'Answer directly and concisely. Do not claim to have called tools or changed files.',
+    'Never add a "Next steps", "Prochaines étapes", "À suivre", options, or suggestions section unless the user explicitly asks what to do next. End after answering the question.',
     'If the user asks for an action that needs workspace commands, MCP tools, services, files, or mutations, say to ask as an agent action instead of pretending to execute it.',
     `Reply language: ${language}.`,
     `Current workspace: ${workspace}.`,
@@ -774,18 +775,21 @@ function rememberProductionActivity(session, payload) {
 
 export function applyRuntimeStateToShellSession(session, state) {
   if (!state || typeof state !== 'object') return false;
+  const displayState = sanitizeRuntimeStateForDisplay(state);
   session.agentProjection = {
-    conversation: Array.isArray(state.conversation) ? state.conversation.map((message) => ({ ...message })) : [],
-    chain: Array.isArray(state.chain) ? state.chain.map((step) => ({ ...step })) : [],
-    plan: Array.isArray(state.plan) ? state.plan.map((step) => ({ ...step })) : null,
-    activities: Array.isArray(state.activities) ? state.activities.map((activity) => ({ ...activity })) : [],
-    logs: Array.isArray(state.logs) ? [...state.logs] : [],
-    summary: state.summary ?? null,
-    status: state.status ?? 'idle',
-    planRevision: state.planRevision ?? 0,
-    planPatches: Array.isArray(state.planPatches) ? state.planPatches.map((patch) => ({ ...patch })) : [],
+    conversation: Array.isArray(displayState.conversation) ? displayState.conversation.map((message) => ({ ...message })) : [],
+    chain: Array.isArray(displayState.chain) ? displayState.chain.map((step) => ({ ...step })) : [],
+    plan: Array.isArray(displayState.plan) && displayState.plan.length > 0
+      ? displayState.plan.map((step) => ({ ...step }))
+      : null,
+    activities: Array.isArray(displayState.activities) ? displayState.activities.map((activity) => ({ ...activity })) : [],
+    logs: Array.isArray(displayState.logs) ? [...displayState.logs] : [],
+    summary: displayState.summary ?? null,
+    status: displayState.status ?? 'idle',
+    planRevision: displayState.planRevision ?? 0,
+    planPatches: Array.isArray(displayState.planPatches) ? displayState.planPatches.map((patch) => ({ ...patch })) : [],
   };
-  session.workflow = state.workflow && typeof state.workflow === 'object'
+  session.workflow = displayState.workflow && typeof displayState.workflow === 'object'
     ? {
         ...state.workflow,
         nodes: Array.isArray(state.workflow.nodes) ? state.workflow.nodes.map((node) => ({ ...node })) : [],
@@ -803,7 +807,7 @@ export function applyRuntimeStateToShellSession(session, state) {
   // Runtime queue items replace the local jobQueue wholesale on every sync.
   // Tag their origin so /queue cancel can refuse to fake-cancel them locally
   // (a local status flip would be silently reverted by the next SSE sync).
-  if (Array.isArray(state.queue)) session.jobQueue = state.queue.map((item) => ({ ...item, origin: 'runtime' }));
+  if (Array.isArray(displayState.queue)) session.jobQueue = displayState.queue.map((item) => ({ ...item, origin: 'runtime' }));
   const production = session.agentProjection.activities.filter((activity) => activity.source === 'production').at(-1);
   if (production) {
     session.productionActivity = {
@@ -817,21 +821,29 @@ export function applyRuntimeStateToShellSession(session, state) {
   return true;
 }
 
-// Submits a prompt to the shared runtime. If the workspace is already busy
-// (HTTP 409 from POST /run), route the input through the runtime control lane
-// so status questions and plan-change proposals do not become future runs.
-// A plain question or small talk must never start a runtime run (nor be
-// enqueued as a future one): it only needs an answer. Route converse/observe
-// to the local agent EVEN during an active run — the chat is supposed to stay
-// available, and the graph already restricts tools to read-only in that case.
-// Actions/cancels/approvals still go to the runtime.
-export function shouldHandleFreeTextLocally(line, session, { llmAvailable = Boolean(session?.llm) } = {}) {
-  const classification = classifyAgentInput(line, session);
-  // cancel intents included: Donna interprets "supprime le job et la queue"
-  // and calls runtime__kill / runtime__cancel herself — no hardcoded regex
-  // deciding between soft and hard stop. The control lane remains the
-  // deterministic fallback when the local LLM is down.
-  if (!['converse', 'observe', 'cancel', 'approve', 'enqueue_run', 'ambiguous'].includes(classification.kind)) return { local: false, classification };
+export function sanitizeRuntimeStateForDisplay(state) {
+  if (!state || typeof state !== 'object') return state;
+  const status = String(state.status ?? 'idle').toLowerCase();
+  const visible = ['running', 'queued', 'pending', 'waiting', 'pending_approval', 'error', 'failed']
+    .includes(status);
+  if (visible) return state;
+  return {
+    ...state,
+    conversation: [],
+    chain: [],
+    plan: [],
+    activities: [],
+    workflow: null,
+    logs: [],
+    summary: null,
+    planPatches: [],
+  };
+}
+
+// In agent mode, Donna receives every free-text turn and decides whether to
+// answer or call an exposed tool. Slash commands remain the deterministic UI.
+export function shouldHandleFreeTextLocally(_line, session, { llmAvailable = Boolean(session?.llm) } = {}) {
+  const classification = { kind: 'agent_turn', confidence: 1, reason: 'agent_mode_llm_decision' };
   if (!llmAvailable) return { local: false, classification, fallbackReason: 'local LLM unavailable' };
   return { local: true, classification };
 }
@@ -1049,17 +1061,12 @@ async function runAgentTurn(input, { agent, session, onUpdate, onStep, displayIn
   };
   session._onStreamReset = () => {
     if (!donnaMessage) return;
-    if (donnaMessage.content.trim()) {
-      // Intermediate streamed text before tool calls: keep it, add separator.
-      donnaMessage.content += '\n\n';
-      onUpdate?.();
-    } else {
-      // Still empty ("Thinking…"): remove it cleanly.
-      const index = messages.indexOf(donnaMessage);
-      if (index !== -1) messages.splice(index, 1);
-      donnaMessage = null;
-      onUpdate?.();
-    }
+    // Text emitted before a tool call is provisional narration, not an answer.
+    // Remove it; the post-tool result gets a fresh Donna bubble.
+    const index = messages.indexOf(donnaMessage);
+    if (index !== -1) messages.splice(index, 1);
+    donnaMessage = null;
+    onUpdate?.();
   };
 
   let agentResult;

package/src/shell/repl.test.js

@@ -9,12 +9,40 @@ import {
   conversationMessages,
   recordRuntimeUnavailableAgentInput,
   runLine,
+  sanitizeRuntimeStateForDisplay,
   runtimeStatusLine,
   runtimeUnavailableAgentMessage,
   shouldHandleFreeTextLocally,
   submitRuntimeRun,
 } from './repl.js';
 
+test('runtime display preserves a failed plan and its diagnostic evidence', () => {
+  const state = {
+    status: 'error',
+    plan: [{ id: 'apply', status: 'failed' }],
+    activities: [{ id: 'job-1', status: 'failed', error: 'exitCode=1' }],
+    logs: ['run_error: ingest_apply exitCode=1'],
+    conversation: [{ role: 'assistant', content: 'Échec de l’ingestion.' }],
+  };
+
+  assert.equal(sanitizeRuntimeStateForDisplay(state), state);
+});
+
+test('runtime display still clears completed historical execution state', () => {
+  const display = sanitizeRuntimeStateForDisplay({
+    status: 'done',
+    plan: [{ id: 'old', status: 'done' }],
+    activities: [{ id: 'old-job', status: 'done' }],
+    logs: ['old log'],
+    conversation: [{ role: 'assistant', content: 'Old run.' }],
+  });
+
+  assert.deepEqual(display.plan, []);
+  assert.deepEqual(display.activities, []);
+  assert.deepEqual(display.logs, []);
+  assert.deepEqual(display.conversation, []);
+});
+
 function stubFetch(handler) {
   const original = globalThis.fetch;
   globalThis.fetch = handler;
@@ -74,6 +102,50 @@ test('applyRuntimeStateToShellSession projects runtime state into shell session'
   assert.deepEqual(conversationMessages(session), []);
 });
 
+test('applyRuntimeStateToShellSession clears terminal plan and activities when runtime is idle', () => {
+  const session = createSession();
+  session.headlessPlan = [{ step: 1, description: 'Old read', status: 'failed' }];
+  session.activities = { old: { key: 'old', status: 'failed', terminal: true } };
+
+  applyRuntimeStateToShellSession(session, {
+    status: 'idle',
+    conversation: [{ role: 'assistant', content: 'Old failed answer' }],
+    chain: [{ id: 'old-step' }],
+    plan: [{ step: 1, description: 'Old read', status: 'failed' }],
+    activities: [{ key: 'old', status: 'failed', terminal: true }],
+    workflow: { nodes: [{ id: 'task:old' }], relations: [] },
+    logs: ['Runtime evaluator rejected the old run'],
+    summary: 'Old run failed',
+    planPatches: [{ id: 'old-patch' }],
+  });
+
+  assert.equal(session.headlessPlan, null);
+  assert.deepEqual(session.activities, {});
+  assert.equal(session.workflow, null);
+  assert.deepEqual(session.agentProjection.logs, []);
+  assert.equal(session.agentProjection.summary, null);
+  assert.deepEqual(session.agentProjection.conversation, []);
+  assert.deepEqual(session.agentProjection.chain, []);
+  assert.deepEqual(session.agentProjection.planPatches, []);
+});
+
+test('direct chat system prompt forbids unsolicited next steps', async () => {
+  const session = createSession();
+  let systemPrompt = '';
+  session.llm = {
+    async *stream({ system }) {
+      systemPrompt = system;
+      yield 'Réponse concise.';
+    },
+  };
+
+  await runLine('bonjour', { agent: null, packageJson: { version: 'test' }, session, chatMode: true });
+
+  assert.match(systemPrompt, /Never add a "Next steps", "Prochaines étapes", "À suivre"/);
+  assert.match(systemPrompt, /unless the user explicitly asks what to do next/);
+  assert.equal(conversationMessages(session).at(-1).content, 'Réponse concise.');
+});
+
 test('submitRuntimeRun reports acceptance without throwing', async () => {
   const restore = stubFetch(async (url) => {
     assert.equal(pathOf(url), '/run');
@@ -241,37 +313,34 @@ test('/queue cancel on a runtime workflow id points to run cancellation commands
   assert.match(conversationMessages(session).at(-1).content, /\/run kill/);
 });
 
-test('free text routing keeps questions local and sends actions to the runtime', () => {
+test('agent mode sends every free-text turn to Donna', () => {
   const session = createSession();
   session.llm = { completeWithTools: () => {} };
 
-  // The original incident: a config question must never start a run.
   const question = shouldHandleFreeTextLocally('donne moi la config du cme', session);
   assert.equal(question.local, true);
-  assert.equal(question.classification.kind, 'observe');
+  assert.equal(question.classification.kind, 'agent_turn');
 
   const smallTalk = shouldHandleFreeTextLocally('bonjour', session);
   assert.equal(smallTalk.local, true);
 
   const action = shouldHandleFreeTextLocally('lance le pipeline complet', session);
-  assert.equal(action.local, false);
-  assert.equal(action.classification.kind, 'start_run');
+  assert.equal(action.local, true);
+  assert.equal(action.classification.kind, 'agent_turn');
+
+  const pending = shouldHandleFreeTextLocally('as ton des fichier en attente d ingestion', session);
+  assert.equal(pending.local, true);
+  assert.equal(pending.classification.kind, 'agent_turn');
 });
 
-test('free text routing keeps questions local even during an active run', () => {
-  // The chat must stay available during a run: a status question or small
-  // talk answered locally (read-only tools) — never enqueued as a future run.
+test('Donna keeps receiving free text during an active run', () => {
   const session = createSession();
   session.llm = { completeWithTools: () => {} };
   session.agentProjection = { status: 'running', activities: [], conversation: [] };
   assert.equal(shouldHandleFreeTextLocally('où en est le run', session).local, true);
   assert.equal(shouldHandleFreeTextLocally('salut', session).local, true);
-  // Cancel intents are handled by Donna locally (runtime__kill/cancel tools);
-  // approvals stay on the deterministic control lane.
   assert.equal(shouldHandleFreeTextLocally('stop le job', session).local, true);
   assert.equal(shouldHandleFreeTextLocally('supprime le job et la queue', session).local, true);
-  // Approvals and "later" requests too: Donna owns runtime__approve and
-  // runtime__enqueue. Only plan modifications and new runs bypass her.
   assert.equal(shouldHandleFreeTextLocally('approuve le run', session).local, true);
   assert.equal(shouldHandleFreeTextLocally('fais le build plus tard', session).local, true);
 

package/src/shell/useSession.ts

@@ -17,6 +17,7 @@ import {
   conversationMessages,
   createSession,
   runtimeUnavailableAgentMessage,
+  sanitizeRuntimeStateForDisplay,
 } from './repl.js';
 import { useAgent } from './useAgent';
 
@@ -340,10 +341,20 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   function mergeRuntimeConversation(state: any) {
     const workspace = (session as any).workspace || '__global__';
     const runtimeConversation = Array.isArray(state?.conversation) ? state.conversation : [];
-    if (runtimeConversation.length === 0) return;
     const target = conversationMessages(session);
     const backed = runtimeConversationRefsByWorkspace.get(workspace) ?? [];
     runtimeConversationRefsByWorkspace.set(workspace, backed);
+    if (runtimeConversation.length === 0) {
+      // Idle runtime display state deliberately has no historical run
+      // conversation. Remove only entries previously merged from that
+      // runtime; preserve local slash-command output and the current input.
+      for (const entry of backed) {
+        const index = target.indexOf(entry);
+        if (index !== -1) target.splice(index, 1);
+      }
+      backed.length = 0;
+      return;
+    }
     // The merge is index-aligned with the runtime conversation array. If that
     // array got SHORTER (runtime restart, projection reset), keeping stale
     // refs would make every new runtime entry silently overwrite an old
@@ -388,8 +399,9 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   function syncRuntimeState() {
     void fetchRuntimeState({ url: props.runtime.url, workspace: (session as any).workspace ?? null })
       .then((state) => {
-        setRuntimeState(state);
-        mergeRuntimeConversation(state);
+        const displayState = sanitizeRuntimeStateForDisplay(state);
+        setRuntimeState(displayState);
+        mergeRuntimeConversation(displayState);
         setRuntimeStatus('connected');
         refresh();
       })