@dotdrelle/wiki-manager 0.15.94 → 0.15.96

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/);
+});

package/src/runtime/server.js

@@ -529,6 +529,20 @@ export function startRuntimeServer({
           }
           return;
         }
+        // A run/job status question is answered by the runtime itself, whatever
+        // the mode and whether or not a run is active. Left to the model it
+        // confused the runtime runId with a production job id ("job not
+        // found"); in chat mode it had no runtime status tool at all.
+        if (asksForRunStatus(input)) {
+          const status = controlStatus(context, store);
+          sendJson(response, 200, {
+            accepted: true,
+            kind: 'observe',
+            ...status,
+            explanation: explainControlState(status),
+          });
+          return;
+        }
         if (context.running && !readOnlyChat) {
           // Agent-mode message while a run is active. Classify once: control
           // verbs and new tasks go to the control lane, plain conversation is
@@ -1632,6 +1646,18 @@ function rejectPlanPatch(context, store, patchId, reason) {
   };
 }
 
+// A question about the run/job currently executing. Deliberately narrow — a
+// status word AND a run/job noun — so it never hijacks an ordinary "explain how
+// X works" question. Such a question must be answered by the runtime itself:
+// left to the model, a runtime runId was mistaken for a production job id and
+// reported as "not found", and a read-only chat turn had no runtime status tool.
+function asksForRunStatus(input) {
+  const text = String(input ?? '');
+  const statusWord = /\b(status|statut|progression|progress|avancement|o[uù] en est|o[uù] en sont)\b/i;
+  const runNoun = /\b(job|run|t[aâ]che|task|build|ingest|pipeline|export|polish|traitement)\b/i;
+  return statusWord.test(text) && runNoun.test(text);
+}
+
 // Classifier for the control lane's free-text messages. The classification is
 // LLM-backed: the only deterministic matches left are the runtime's own
 // control verbs (cancel, an explicit "later/queue", status and plan-change
@@ -1668,6 +1694,14 @@ async function classifyControlMessage(input, status, { forcedIntent = null, llm
   if (/\b(o[uù] en es[t-]|status|statut|progress|progression|logs?|explique|explain|inspect|show|montre|quoi de neuf)\b/i.test(lower)) {
     return { kind: 'observe', confidence: 0.86, reason: 'status_or_explanation_request' };
   }
+  // A bare "yes" answers the runtime's own last prompt (the launch
+  // acknowledgement used to end on "check progress or cancel?"). While a run is
+  // active, the only thing the runtime can act on is a status check: treating
+  // the word as ordinary conversation made the read-only chat fallback lecture
+  // the user about switching modes instead of answering.
+  if (status.running && /^\s*(oui|yes|yep|ok|okay|vas[- ]?y|d'accord|daccord|entendu)\b/i.test(lower)) {
+    return { kind: 'observe', confidence: 0.7, reason: 'confirmation_of_runtime_prompt' };
+  }
   if (status.running && /\b(ajoute|add|change|modifie|modify|remplace|replace|retire|remove|skip|ignore|apr[eè]s|before|after|chaque|each|plan|step|t[aâ]che)\b/i.test(lower)) {
     return { kind: 'modify_run', confidence: 0.78, reason: 'active_run_change_request' };
   }

package/src/runtime/server.test.js

@@ -1733,6 +1733,93 @@ test('POST /turn keeps informational skill and build questions conversational',
   }
 });
 
+test('POST /turn answers a run status question from the runtime instead of the model', async (t) => {
+  const session = { workspace: 'acme', controlQueue: [] };
+  const context = { workspace: 'acme', session, running: true, currentAbortController: null };
+  const status = {
+    status: 'running',
+    running: true,
+    plan: [{ step: 1, description: 'Build TechSections', status: 'running' }],
+    queue: [],
+    controlQueue: [],
+    approvals: [],
+    conversation: [],
+  };
+  let turns = 0;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => status, listEvents: () => [] },
+      getContext: async () => context,
+      run: async () => new Promise(() => {}),
+      turn: async () => { turns += 1; return { ok: true }; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    // The model once mistook the runtime runId for a production job id and
+    // answered "job not found". The runtime answers its own status.
+    const response = await fetch(`http://127.0.0.1:${handle.port}/turn?workspace=acme`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ input: 'donne le status du job en cours', mode: 'agent' }),
+    });
+    const body = await response.json();
+    assert.equal(response.status, 200);
+    assert.equal(body.kind, 'observe');
+    assert.match(body.explanation, /Build TechSections/);
+    assert.equal(turns, 0);
+  } finally {
+    context.currentAbortController?.abort();
+    await handle.close();
+  }
+});
+
+test('POST /turn treats a bare confirmation during a run as a status check', async (t) => {
+  const session = { workspace: 'acme', controlQueue: [] };
+  const context = { workspace: 'acme', session, running: true, currentAbortController: null };
+  const status = {
+    status: 'running',
+    running: true,
+    plan: [{ step: 1, description: 'Rebuild the wiki', status: 'running' }],
+    queue: [],
+    controlQueue: [],
+    approvals: [],
+    conversation: [],
+  };
+  let turns = 0;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => status, listEvents: () => [] },
+      getContext: async () => context,
+      run: async () => new Promise(() => {}),
+      turn: async () => { turns += 1; return { ok: true }; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    // "oui" answers the launch acknowledgement. It must reach the runtime's
+    // status, not a read-only chat turn that lectures about switching modes.
+    const response = await fetch(`http://127.0.0.1:${handle.port}/turn?workspace=acme`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ input: 'oui', mode: 'agent' }),
+    });
+    const body = await response.json();
+    assert.equal(response.status, 200);
+    assert.equal(body.kind, 'observe');
+    assert.equal(turns, 0);
+  } finally {
+    context.currentAbortController?.abort();
+    await handle.close();
+  }
+});
+
 test('POST /run accepts named skill arguments and deduplicates an explicit retry key', async (t) => {
   const root = mkdtempSync(join(tmpdir(), 'runtime-named-skill-'));
   mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });

package/src/runtime/skillRun.js

@@ -165,7 +165,7 @@ export async function generateSkillAcknowledgment(session, { publicInput, object
       // slow provider must not block the skill-launch HTTP response forever.
       const reply = await llm.complete({
         system: 'You are Donna, the workspace assistant. You acknowledge a launched workflow in the user\'s language. Be concise: exactly one short sentence.',
-        input: `The user just launched the workspace skill ${publicInput}. It was compiled into ${count} step(s) and is now running.\n\nWrite ONE short sentence in ${language} that confirms the launch, echoes the skill and its arguments, and says progress will be reported. Return only that sentence, nothing else.`,
+        input: `The user just launched the workspace skill ${publicInput}. It was compiled into ${count} step(s) and is now running.\n\nWrite ONE short sentence in ${language} that confirms the launch, echoes the skill and its arguments, and says progress will be reported. Do not ask a question, do not propose options, and do not offer to check, monitor or cancel anything: the runtime reports progress on its own and this acknowledgement is not a decision point. Return only that sentence, nothing else.`,
         signal: AbortSignal.timeout(8_000),
       });
       const text = String(reply ?? '').trim();

package/src/runtime/skillRun.test.js

@@ -94,6 +94,9 @@ test('generateSkillAcknowledgment asks Donna in the session language and echoes
   assert.equal(calls.length, 1);
   assert.match(calls[0].input, /es/);
   assert.match(calls[0].input, /\/deliver deliverable="Informe"/);
+  // The acknowledgement is not a decision point: it must not invite the user
+  // into a dialog the runtime cannot act on.
+  assert.match(calls[0].input, /Do not ask a question/);
 });
 
 test('generateSkillAcknowledgment degrades to a neutral message without an LLM client', async () => {

package/src/shell/repl.js

@@ -1583,13 +1583,17 @@ async function runChatToolLoop({ input, session, history, donnaMessage, onUpdate
     executeCall,
     maxIterations: Math.min(8, Number(session?.chatAccess?.maxToolIterations) || 4),
     signal: session._abortSignal,
-    onStep: (i, cap) => onStep?.(`Chat: consulting… [${i}/${cap}]`),
+    onStep: () => onStep?.('Chat: consulting…'),
     onTextDelta,
     onTextReset,
   });
-  donnaMessage.content = capped
+  // A capped turn now asks the model for a final answer without tools, so an
+  // answer may exist even when the loop hit its limit: show it. Only fall back
+  // to the honest limit notice when there is genuinely nothing to show.
+  const answer = stripDsmlArtifacts(content).trim();
+  donnaMessage.content = answer || (capped
     ? 'Could not finish within the chat mode iteration limit. Switch to /agent if needed.'
-    : (stripDsmlArtifacts(content).trimEnd() || formatLlmUnavailableMessage('empty response'));
+    : formatLlmUnavailableMessage('empty response'));
   onUpdate?.();
 }