@dotdrelle/wiki-manager 0.15.94 → 0.15.97

package/src/core/skillChainView.js

@@ -7,6 +7,8 @@
  * which is why the shaping lives here and not in either renderer.
  */
 
+import { TERMINAL_STATUS_SET } from '../orchestrator/taskStatuses.js';
+
 const SYMBOLS = {
   done: '✓',
   running: '●',
@@ -29,7 +31,7 @@ export function selectionKindLabel(selectionKind) {
   return SELECTION_KIND_LABELS[selectionKind] ?? selectionKind ?? null;
 }
 
-export const TERMINAL = new Set(['done', 'failed', 'cancelled', 'skipped']);
+export const TERMINAL = TERMINAL_STATUS_SET;
 
 // Objectives are whole paragraphs; a chain view needs a line. Keep the first
 // sentence, drop the parameter block the compiler appends, and never cut a word

package/src/core/toolLoop.js

@@ -38,7 +38,15 @@ export async function runBoundedToolLoop({
   // livre le texte au fil de l'eau. Sans lui, la réponse finale n'apparaissait
   // qu'une fois complète — le tour paraissait figé pendant toute sa durée.
   const canStream = typeof onTextDelta === 'function' && typeof llm?.streamWithTools === 'function';
+  // The exact same tool + arguments called again is a loop, not progress: a
+  // model that keeps re-issuing `search("x")` will never finish, and burning
+  // the whole iteration cap on it only produced "could not finish". Track the
+  // signatures and stop as soon as a turn repeats one already executed.
+  const seen = new Set();
+  const signature = (call) => `${call?.function?.name ?? ''}\u0000${String(call?.function?.arguments ?? '')}`;
+  let iterations = 0;
   for (let i = 0; i < cap; i += 1) {
+    iterations = i + 1;
     onStep?.(i + 1, cap);
     let streamedText = false;
     const result = canStream
@@ -62,10 +70,12 @@ export async function runBoundedToolLoop({
     if (calls.length === 0) {
       return {
         content: result?.content ?? result?.message?.content ?? '',
-        iterations: i + 1,
+        iterations,
         capped: false,
       };
     }
+    if (calls.every((call) => seen.has(signature(call)))) break;
+    for (const call of calls) seen.add(signature(call));
     convo.push(result.message ?? { role: 'assistant', content: result.content ?? '', tool_calls: calls });
     // Tool calls within one turn are independent: dispatch concurrently, then
     // replay results in the model's call order so the transcript stays stable.
@@ -77,5 +87,49 @@ export async function runBoundedToolLoop({
       convo.push({ role: 'tool', tool_call_id: outcome.tool_call_id, content: outcome.content });
     }
   }
-  return { content: '', iterations: cap, capped: true };
+  // Cap reached or a loop detected: ask once more WITHOUT tools for the best
+  // answer the results gathered so far support. Returning '' here is what made
+  // a long search end in a dead-end instead of the partial answer it had
+  // already collected.
+  const content = await finalAnswerWithoutTools({ llm, system, convo, canStream, onTextDelta, onTextReset, signal });
+  return { content, iterations, capped: true };
+}
+
+async function finalAnswerWithoutTools({
+  llm,
+  system,
+  convo,
+  canStream,
+  onTextDelta,
+  onTextReset,
+  signal,
+}) {
+  try {
+    if (canStream) {
+      let text = '';
+      const result = await llm.streamWithTools({
+        system,
+        tools: [],
+        messages: convo,
+        toolChoice: 'auto',
+        onTextDelta: (delta) => { text += delta; onTextDelta(delta); },
+        signal,
+      });
+      // A tool call despite the empty toolset is not an answer: drop whatever
+      // it streamed and let the caller fall back to its own message.
+      if (result?.tool_calls?.length) { onTextReset?.(); return ''; }
+      return String(result?.content ?? text ?? '').trim();
+    }
+    const result = await llm.completeWithTools({
+      system,
+      tools: [],
+      messages: convo,
+      toolChoice: 'auto',
+      signal,
+    });
+    if (result?.tool_calls?.length) return '';
+    return String(result?.content ?? result?.message?.content ?? '').trim();
+  } catch {
+    return '';
+  }
 }

package/src/core/toolLoop.test.js

@@ -61,16 +61,47 @@ test('runs concurrent tool calls and replays results in call order', async () =>
   assert.deepEqual(order, ['a', 'b']); // preserved model call order
 });
 
-test('reports capped when the model keeps calling tools past the cap', async () => {
+test('stops on a repeated identical tool call instead of burning the cap', async () => {
   const llm = {
-    async completeWithTools() {
+    async completeWithTools({ tools }) {
+      if (tools.length === 0) return { content: 'Synthèse des résultats.', tool_calls: [] };
       const calls = [toolCall('x', 's__status')];
       return { message: { role: 'assistant', content: '', tool_calls: calls }, tool_calls: calls };
     },
   };
-  const out = await runBoundedToolLoop({ llm, tools: [], executeCall: async () => 'r', maxIterations: 3 });
+  const out = await runBoundedToolLoop({
+    llm,
+    tools: [{ function: { name: 's__status' } }],
+    executeCall: async () => 'r',
+    maxIterations: 8,
+  });
+  assert.equal(out.capped, true);
+  // The same call twice is a loop: it stopped well before the cap.
+  assert.ok(out.iterations < 8, `expected an early stop, got ${out.iterations}`);
+  // And the turn still answers from what it gathered instead of a dead-end.
+  assert.equal(out.content, 'Synthèse des résultats.');
+});
+
+test('answers from the gathered results when the cap is reached', async () => {
+  let round = 0;
+  const llm = {
+    async completeWithTools({ tools }) {
+      round += 1;
+      if (round <= 2 && tools.length > 0) {
+        const calls = [toolCall('x', 's__search', `{"q":"${round}"}`)];
+        return { message: { role: 'assistant', content: '', tool_calls: calls }, tool_calls: calls };
+      }
+      return { content: "Voici ce que j'ai trouvé.", tool_calls: [] };
+    },
+  };
+  const out = await runBoundedToolLoop({
+    llm,
+    tools: [{ function: { name: 's__search' } }],
+    executeCall: async () => 'r',
+    maxIterations: 2,
+  });
   assert.equal(out.capped, true);
-  assert.equal(out.iterations, 3);
+  assert.equal(out.content, "Voici ce que j'ai trouvé.");
 });
 
 test('propagates an abort thrown by executeCall', async () => {

package/src/orchestrator/agentRegistry.js

@@ -1,5 +1,6 @@
 import { createAgentEvent, dispatchAgentEvent, dispatchRuntimeLog } from '../core/agentEvents.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
+import { cloneJson } from '../core/json.js';
 import { assertContract } from '../contracts/schemas.js';
 
 const AVAILABLE = 'available';
@@ -320,6 +321,3 @@ function cloneAgent(agent) {
   };
 }
 
-function cloneJson(value) {
-  return value == null ? value : JSON.parse(JSON.stringify(value));
-}

package/src/orchestrator/dependencyResolver.js

@@ -174,6 +174,3 @@ function taskId(task) {
   return String(task?.id ?? task?.step);
 }
 
-export function isTerminalTask(task) {
-  return isTerminal(statusOf(task));
-}

package/src/orchestrator/planValidator.js

@@ -1,4 +1,5 @@
 import { validateContract } from '../contracts/schemas.js';
+import { cloneJson } from '../core/json.js';
 
 const SUPPORTED_CONTRACT_VERSIONS = new Set(['1']);
 const MUTATING_OPERATIONS = new Set([
@@ -529,6 +530,3 @@ function issue(code, message, details = {}) {
   return { code, message, details };
 }
 
-function cloneJson(value) {
-  return value == null ? value : JSON.parse(JSON.stringify(value));
-}

package/src/orchestrator/providers/runtimeProvider.js

@@ -43,20 +43,6 @@ import { assertContract } from '../../contracts/schemas.js';
 
 export const RUNTIME_PROTOCOL_VERSION = '1';
 
-export const RUNTIME_EVENT_TYPES = [
-  'run_created',
-  'run_started',
-  'agent_thinking',
-  'tool_started',
-  'tool_finished',
-  'subagent_started',
-  'subagent_finished',
-  'message',
-  'approval_required',
-  'run_completed',
-  'run_failed',
-  'run_cancelled',
-];
 
 export class RuntimeProviderUnavailableError extends Error {
   constructor(runtime, reason) {

package/src/orchestrator/taskStatuses.js

@@ -28,6 +28,14 @@ export const PENDING_STATUSES_LIST = Object.freeze(['pending', 'pending_approval
 /** En cours : un agent y travaille en ce moment. */
 export const ACTIVE_STATUSES = Object.freeze(['running', 'in_progress', 'started', 'starting']);
 
+/**
+ * Terminal, réduit à ses quatre formes canoniques (les alias sont normalisés
+ * avant comparaison). Les modules qui recopiaient `['done','failed',
+ * 'cancelled','skipped']` dans un `Set` importent celui-ci à la place.
+ */
+export const TERMINAL_STATUSES = Object.freeze(['done', 'failed', 'cancelled', 'skipped']);
+export const TERMINAL_STATUS_SET = new Set(TERMINAL_STATUSES);
+
 const ALIASES = new Map([
   ...SUCCESS_STATUSES.map((status) => [status, 'done']),
   ...FAILURE_STATUSES.map((status) => [status, 'failed']),

package/src/runtime/client.js

@@ -238,19 +238,6 @@ export async function postRuntimeShutdown({
   return response.json();
 }
 
-export async function postRuntimeResume({
-  url = runtimeUrlFromEnv(),
-  token = runtimeToken(),
-  workspace = null,
-} = {}) {
-  const response = await fetch(runtimeEndpoint(url, '/resume', workspace), {
-    method: 'POST',
-    headers: runtimeHeaders(token),
-  });
-  if (!response.ok) throw new Error(`Runtime resume failed: HTTP ${response.status}`);
-  return response.json();
-}
-
 export async function postRuntimeApprove({
   url = runtimeUrlFromEnv(),
   token = runtimeToken(),
@@ -331,6 +318,3 @@ export async function* streamRuntimeEvents({
   }
 }
 
-export function runtimeFetchOptions(token = runtimeToken()) {
-  return { headers: runtimeHeaders(token) };
-}

package/src/runtime/controlDrain.js

@@ -1,10 +1,13 @@
 /**
  * @statuses-vocabulary
  * Control items are queued run requests, not orchestrator tasks. Their
- * terminal vocabulary deliberately includes chain-level `skipped` and is
- * projected by core/agentEvents.js rather than taskStatuses.js.
+ * terminal vocabulary is the same four canonical statuses as a task's
+ * (`TERMINAL_STATUS_SET`), including chain-level `skipped`; the projection is
+ * still done by core/agentEvents.js, this only shares the vocabulary.
  */
-const TERMINAL = new Set(['done', 'failed', 'cancelled', 'skipped']);
+import { TERMINAL_STATUS_SET } from '../orchestrator/taskStatuses.js';
+
+const TERMINAL = TERMINAL_STATUS_SET;
 
 export function reconcileControlQueue(context, { startItem, skipItem } = {}) {
   if (!context?.session || context.running || context.controlDrainActive) return false;

package/src/runtime/deltaCoalescer.js

@@ -0,0 +1,53 @@
+/*
+ * Coalesces streaming text fragments before they are persisted and pushed.
+ *
+ * The runtime persisted one SQLite row (plus one SSE write) per streamed token.
+ * When a tool pulled a lot of content into the thread, the answer narrating it
+ * grew long and those synchronous writes stalled the event loop: both chats
+ * (serve and ShellUI) froze while the answer was still being produced. Buffering
+ * the fragments and flushing them at a bounded rate turns thousands of writes
+ * into a handful without changing what the reader sees.
+ *
+ * Ordering matters: `flush()` must be called before any non-delta event, or a
+ * final message could overtake the fragments that precede it. `reset()` drops
+ * buffered text that turned out to be provisional narration (a tool-call
+ * iteration), matching `assistant_delta_reset`.
+ */
+export function createDeltaCoalescer(flush, { intervalMs = 80 } = {}) {
+  if (typeof flush !== 'function') throw new TypeError('createDeltaCoalescer requires a flush callback.');
+  const delay = Math.max(1, Math.floor(intervalMs) || 80);
+  let buffer = '';
+  let timer = null;
+  const emit = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (!buffer) return;
+    const delta = buffer;
+    buffer = '';
+    flush(delta);
+  };
+  return {
+    push(delta) {
+      const text = String(delta ?? '');
+      if (!text) return;
+      buffer += text;
+      if (!timer) timer = setTimeout(emit, delay);
+    },
+    flush: emit,
+    reset() {
+      buffer = '';
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    },
+    dispose() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    },
+  };
+}

package/src/runtime/deltaCoalescer.test.js

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createDeltaCoalescer } from './deltaCoalescer.js';
+
+const tick = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+test('coalesces fragments pushed within the interval into one flush', async () => {
+  const flushed = [];
+  const coalescer = createDeltaCoalescer((delta) => flushed.push(delta), { intervalMs: 20 });
+  coalescer.push('Bon');
+  coalescer.push('jour ');
+  coalescer.push('le monde.');
+  assert.deepEqual(flushed, [], 'rien ne doit partir avant l\'intervalle');
+  await tick(35);
+  assert.deepEqual(flushed, ['Bonjour le monde.']);
+});
+
+test('flush() emits the buffered fragments immediately, in order', () => {
+  const flushed = [];
+  const coalescer = createDeltaCoalescer((delta) => flushed.push(delta), { intervalMs: 1000 });
+  coalescer.push('a');
+  coalescer.push('b');
+  coalescer.flush();
+  assert.deepEqual(flushed, ['ab']);
+  // Nothing left to flush twice.
+  coalescer.flush();
+  assert.deepEqual(flushed, ['ab']);
+});
+
+test('reset() drops buffered provisional narration', () => {
+  const flushed = [];
+  const coalescer = createDeltaCoalescer((delta) => flushed.push(delta), { intervalMs: 1000 });
+  coalescer.push('je vais regarder…');
+  coalescer.reset();
+  coalescer.flush();
+  assert.deepEqual(flushed, []);
+});
+
+test('a single flush covers fragments that arrive after a first flush', async () => {
+  const flushed = [];
+  const coalescer = createDeltaCoalescer((delta) => flushed.push(delta), { intervalMs: 20 });
+  coalescer.push('un ');
+  await tick(30);
+  coalescer.push('deux');
+  await tick(30);
+  assert.deepEqual(flushed, ['un ', 'deux']);
+});
+
+test('dispose() stops the pending timer without emitting', async () => {
+  const flushed = [];
+  const coalescer = createDeltaCoalescer((delta) => flushed.push(delta), { intervalMs: 20 });
+  coalescer.push('perdu');
+  coalescer.dispose();
+  await tick(40);
+  assert.deepEqual(flushed, []);
+});

package/src/runtime/loginPage.js

@@ -127,6 +127,3 @@ export function loginPageHtml({ enrolled = false, secret = null, uri = null, err
 </html>`;
 }
 
-export function loginSuccessHtml(sessionExpiresAt) {
-  return loginPageHtml({ enrolled: true, sessionExpiresAt });
-}

package/src/runtime/loginSession.js

@@ -1,4 +1,4 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { randomBytes } from 'node:crypto';
 import { defaultRuntimeStateDir } from '../core/env.js';
@@ -221,6 +221,3 @@ export function pruneLoginAttempts() {
   }
 }
 
-export function sessionExists() {
-  return existsSync(sessionPath());
-}

package/src/runtime/runner.js

@@ -303,12 +303,13 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
 // instead of the client streaming a per-job line for every task. Uses the
 // workspace LLM to phrase it, degrading to a plain templated fact line if the
 // LLM is unavailable or errors — the run must never block on this summary.
-async function announceRunOutcome(session, { runId, ok, signal = null } = {}) {
+export async function announceRunOutcome(session, { runId, ok, signal = null } = {}) {
   const plan = Array.isArray(session.headlessPlan) ? session.headlessPlan : [];
   if (plan.length === 0) return;
   let failed = 0;
   let cancelled = 0;
   let completed = 0;
+  let pending = 0;
   let firstError = null;
   for (const step of plan) {
     const status = String(step?.status ?? '').toLowerCase();
@@ -322,12 +323,24 @@ async function announceRunOutcome(session, { runId, ok, signal = null } = {}) {
       cancelled += 1;
     } else if (isSuccessful(status)) {
       completed += 1;
+    } else if (isPending(status) || !isTerminal(status)) {
+      // pending_approval, waiting_approval, running, unknown: the work has NOT
+      // happened. Counting these as neither success nor failure is what made a
+      // run that had only *planned* its mutations announce a success (LLM
+      // rephrasing "0/N réussie" into "le livrable a bien été publié") before
+      // the approval that would actually run it.
+      pending += 1;
     }
   }
   const total = plan.length;
-  const factLine = ok && failed === 0
+  const finished = ok && failed === 0 && cancelled === 0 && pending === 0 && completed === total;
+  const factLine = finished
     ? `Plan terminé avec succès — ${completed}/${total} tâche(s) réussie(s).`
-    : `Plan terminé en erreur — ${completed}/${total} tâche(s) réussie(s), ${failed} en erreur${cancelled ? `, ${cancelled} annulée(s)` : ''}.${firstError ? ` Première erreur : ${firstError}.` : ''}`;
+    : `Plan non terminé — ${completed}/${total} tâche(s) réussie(s)` +
+      `${pending ? `, ${pending} en attente (approbation ou exécution)` : ''}` +
+      `${failed ? `, ${failed} en erreur` : ''}` +
+      `${cancelled ? `, ${cancelled} annulée(s)` : ''}.` +
+      `${firstError ? ` Première erreur : ${firstError}.` : ''}`;
   let content = factLine;
   const llm = session.llm;
   if (llm && typeof llm.completeWithTools === 'function') {
@@ -337,6 +350,7 @@ async function announceRunOutcome(session, { runId, ok, signal = null } = {}) {
           'You are Donna, an orchestration assistant reporting a run result to the user.',
           'Rephrase the outcome facts in ONE short, natural sentence, in the same language as the facts.',
           'No lists, no headers, no raw job ids — just a concise human summary.',
+          'If the facts say the plan is NOT finished, say so plainly and name what is still pending or failed: never claim the work was completed, published or successful.',
         ].join('\n'),
         tools: [],
         messages: [{ role: 'user', content: `Run outcome facts:\n${factLine}` }],

package/src/runtime/runner.test.js

@@ -4,7 +4,7 @@ import { createAgentEvent, dispatchAgentEvent, reduceAgentEvents } from '../core
 import { tasksAwaitingApproval } from '../orchestrator/dependencyResolver.js';
 import { isTerminal } from '../orchestrator/taskStatuses.js';
 import { readyPlanTasks } from '../core/planPatch.js';
-import { skipImpossibleTasks, structuredPlanEvaluation, ensurePlanProjection, evaluateRuntimeRun, finishRuntimeRun, materializeTaskInputs, replanRuntimeRun, runRuntimeAgenticWorkflow, runRuntimeParallelPlan, shouldUseParallelScheduler } from './runner.js';
+import { skipImpossibleTasks, structuredPlanEvaluation, ensurePlanProjection, evaluateRuntimeRun, finishRuntimeRun, materializeTaskInputs, replanRuntimeRun, runRuntimeAgenticWorkflow, runRuntimeParallelPlan, shouldUseParallelScheduler, announceRunOutcome } from './runner.js';
 
 test('ensurePlanProjection re-projects when the chained plan changes shape (step 2)', () => {
   const session = { agentEvents: [], agentProjection: null };
@@ -1288,3 +1288,34 @@ test('rejouer les événements redonne exactement les mêmes statuts', () => {
   );
   assert.deepEqual(replayed.plan.map((step) => step.status), ['failed', 'skipped']);
 });
+
+test('announceRunOutcome never calls a plan with pending tasks a success', async () => {
+  // The outcome summary counted only failed/cancelled/successful, so a run
+  // whose single mutating task was still `pending_approval` produced
+  // "Plan terminé avec succès — 0/1 réussie", which the model rephrased into
+  // "le livrable a bien été publié" — before the approval that would run it.
+  const session = {
+    agentEvents: [],
+    agentProjection: null,
+    headlessPlan: [{ id: 'a', description: 'Build TechSections', status: 'pending_approval' }],
+  };
+  await announceRunOutcome(session, { runId: 'run-1', ok: true });
+  const message = session.agentEvents.find((event) => event.type === 'assistant_message');
+  assert.match(message.payload.content, /non terminé/i);
+  assert.match(message.payload.content, /en attente/);
+  assert.doesNotMatch(message.payload.content, /succès/i);
+});
+
+test('announceRunOutcome reports success only when every task finished', async () => {
+  const session = {
+    agentEvents: [],
+    agentProjection: null,
+    headlessPlan: [
+      { id: 'a', description: 'Build TechSections', status: 'done' },
+      { id: 'b', description: 'Export', status: 'success' },
+    ],
+  };
+  await announceRunOutcome(session, { runId: 'run-2', ok: true });
+  const message = session.agentEvents.find((event) => event.type === 'assistant_message');
+  assert.match(message.payload.content, /succès/);
+});