@dotdrelle/wiki-manager 0.15.60 → 0.15.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.60",
+  "version": "0.15.62",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "repository": {
     "type": "git",

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.60",
-  "commit": "8c5c615"
+  "version": "0.15.62",
+  "commit": "399432f"
 }

package/src/core/mcp.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { managerEnvFile, managerMcpEndpointsFile, readEnvFile } from './env.js';
 
-const WIKI_MANAGER_VERSION = '0.15.60';
+const WIKI_MANAGER_VERSION = '0.15.62';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/skillCompiler.test.js

@@ -31,7 +31,7 @@ test('validation rejects technical routing details', () => {
 });
 
 test('scaffold skills preserve existing capabilities and split only wiki-sync', async () => {
-  const expected = { pipeline: 1, 'wiki-ingest': 1, 'wiki-build': 1, deliver: 1, diagnose: 1, status: 1, 'new-template': 1, 'wiki-sync': 2 };
+  const expected = { pipeline: 1, 'wiki-ingest': 2, 'wiki-build': 1, deliver: 1, diagnose: 1, status: 1, 'new-template': 1, 'wiki-sync': 2 };
   for (const [name, count] of Object.entries(expected)) {
     const raw = readFileSync(resolve('../llm-wiki/scaffold/workspace/.wiki/skills', `${name}.md`), 'utf8');
     const { meta, body } = parseFrontmatter(raw);

package/src/runtime/controlMessages.js

@@ -13,6 +13,7 @@
 
 const CONTROL_MESSAGES = {
   queued_for_future_run: 'Request added to the queue — it will start automatically after the current run.',
+  control_run_started: 'A queued request is now starting.',
   plan_patch_proposed: 'Plan patch proposed. Approve it explicitly to apply it to the active plan.',
   ambiguous_control: 'A run is already active, and this looks like a new action. Say "queue it" to run it after the current run, "modify the run" to change the active plan, "cancel" to stop the current run first — or wait for it to finish.',
   converse_while_running: 'Runtime run is still active. This message was treated as conversation and did not create a queued run.',

package/src/runtime/server.js

@@ -12,6 +12,7 @@ import { matchSkillInvocation } from '../core/skillInvocation.js';
 import { reconcileControlQueue } from './controlDrain.js';
 import { cancelControlChain, cancelQueuedControlItem } from './controlCancellation.js';
 import { generateSkillAcknowledgment, runSkillChain } from './skillRun.js';
+import { emitRuntimeLog } from './supervisor.js';
 import { findSkill, listSkills } from '../core/skills.js';
 
 const PRIVATE_CONTROL_INPUTS = new WeakMap();
@@ -780,7 +781,7 @@ export function startRuntimeServer({
     return { killed: true, workspace: targetWorkspace, runId: targetRunId, runs, tasks, queued, ...(purged !== null ? { purged } : {}) };
   }
 
-  function startRuntimeRun(context, body, { controlItemId = null, waitForPlan = false } = {}) {
+  function startRuntimeRun(context, body, { controlItemId = null, waitForPlan = false, announceLaunch = false } = {}) {
     const runId = randomUUID();
     const runWorkspace = context.workspace ?? body.workspace ?? null;
     context.running = true;
@@ -803,6 +804,14 @@ export function startRuntimeServer({
         workspace: runWorkspace,
         payload: { id: controlItemId, runId },
       }));
+      // A control item is now a live run: announce it in the conversation so the
+      // "queued" acknowledgement is closed out by a "starting" one. A task is a
+      // task whether it waited or not — it is about to go through approval — so
+      // this is not gated on having waited. Skill-chain steps are skipped: they
+      // already announced the whole skill at invocation.
+      if (announceLaunch) {
+        announceControlLaunch(context.session, body.publicInput ?? body.input, runWorkspace);
+      }
     }
     const runPromise = run(context, runBody, { signal: context.currentAbortController.signal, runId });
     runPromise
@@ -860,7 +869,7 @@ export function startRuntimeServer({
             },
           }
           : {}),
-      }, { controlItemId: item.id }),
+      }, { controlItemId: item.id, announceLaunch: !item.chainId }),
       skipItem: (item, reason) => {
         privateControlInputsFor(context.session).delete(item.id);
         emitControlSkipped(context, item, reason);
@@ -1091,7 +1100,11 @@ export function approvalRequestFromStatus(status) {
 
 async function handleControlMessage(context, store, input, { intent = null, startNextControlRequest = () => false, cancel = null, approve = null } = {}) {
   const status = controlStatus(context, store);
-  const classification = classifyControlMessage(input, status, intent);
+  const classification = await classifyControlMessage(input, status, {
+    forcedIntent: intent,
+    llm: context?.session?.llm,
+    session: context?.session,
+  });
   if (classification.kind === 'observe') {
     return readOnlyControlResponse('observe', classification, status, explainControlState(status));
   }
@@ -1129,6 +1142,7 @@ async function handleControlMessage(context, store, input, { intent = null, star
     // startNextControlRequest), which can change running/plan/status — a full
     // controlStatus() recompute is required here, not just controlQueue.
     void startNextControlRequest(context);
+    const explanation = await generateControlAcknowledgment(context?.session, { kind: 'queued', input });
     return {
       statusCode: 202,
       body: {
@@ -1137,7 +1151,7 @@ async function handleControlMessage(context, store, input, { intent = null, star
         classification,
         item,
         ...controlStatus(context, store),
-        explanation: controlMessage(context?.session, 'queued_for_future_run'),
+        explanation,
       },
     };
   }
@@ -1158,6 +1172,61 @@ async function handleControlMessage(context, store, input, { intent = null, star
     : controlMessage(context?.session, 'converse_while_idle'));
 }
 
+/*
+ Control-lane acknowledgements are Donna's to localize.
+
+ The control lane stays deterministic in its CLASSIFICATION and its actions,
+ but the acknowledgement the user reads ("queued, will run after this one" /
+ "the queued task is starting") is a conversational reply: it goes through a
+ single bounded LLM completion, like the skill-launch acknowledgement, and
+ falls back to the deterministic English catalog when no LLM is configured or
+ the call fails. The fallback is what keeps the lane deterministic-under-failure.
+ */
+async function generateControlAcknowledgment(session, { kind, input }) {
+  const language = String(session?.language ?? '').trim().toLowerCase() || 'en';
+  const llm = session?.llm;
+  const fallback = kind === 'queued'
+    ? controlMessage(session, 'queued_for_future_run')
+    : controlMessage(session, 'control_run_started');
+  if (llm && typeof llm.complete === 'function') {
+    try {
+      const scenario = kind === 'queued'
+        ? 'The user requested a new task while a run is active. It was queued and will start automatically after the current run finishes.'
+        : 'A task the user queued earlier is now starting.';
+      const instruction = kind === 'queued'
+        ? 'their request is queued and will run after the current run finishes'
+        : 'the queued task is now starting';
+      const reply = await llm.complete({
+        system: 'You are Donna, the workspace assistant. You acknowledge a runtime queue event in the user\'s language. Be concise: exactly one short sentence.',
+        input: `${scenario}\n\nThe task is: ${input}\n\nWrite ONE short sentence in ${language} that tells the user ${instruction}. Return only that sentence, nothing else.`,
+        signal: AbortSignal.timeout(8_000),
+      });
+      const text = String(reply ?? '').trim();
+      if (text) return text;
+      emitRuntimeLog(session, 'control-acknowledgment: LLM returned an empty reply, using the deterministic fallback');
+    } catch (err) {
+      // A degradation must announce itself: silently falling through here
+      // hides the difference between "no LLM configured" (expected) and "the
+      // configured LLM is failing every call" (a real problem) — both would
+      // otherwise look identical from the Shell or serve UI.
+      emitRuntimeLog(session, `control-acknowledgment: LLM call failed, using the deterministic fallback — ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return fallback;
+}
+
+function announceControlLaunch(session, input, workspace) {
+  void generateControlAcknowledgment(session, { kind: 'started', input })
+    .then((content) => {
+      dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+        origin: 'runtime',
+        workspace,
+        payload: { content, independent: true },
+      }));
+    })
+    .catch(() => {});
+}
+
 /*
  `skillStack` accompagne l'élément, il ne vit pas sur la session.
 
@@ -1353,13 +1422,15 @@ function rejectPlanPatch(context, store, patchId, reason) {
   };
 }
 
-// Interim classifier for control §4.2 of the plan directeur: the plan expects
-// an LLM-backed classification eventually ("la classification LLM se
-// trompera" — the plan's own fallback-UX rule presupposes an LLM). This is a
-// synchronous keyword/regex stand-in with the same {kind, confidence, reason}
-// contract, so swapping in an LLM call later shouldn't require touching
-// handleControlMessage.
-function classifyControlMessage(input, status, forcedIntent = null) {
+// Classifier for control §4.2 of the plan directeur. The plan expects an
+// LLM-backed classification — "the classification LLM se trompera" — and this
+// is that, now: the only deterministic matches left are the runtime's own
+// control verbs (cancel, an explicit "later/queue", status and plan-change
+// wording). Deciding "is this a NEW task to queue vs plain conversation" is a
+// semantic judgement about the workspace's domain, so it is never a keyword
+// list here — it goes to the model, bounded, and falls back to the choice menu
+// (`ambiguous`) rather than guessing when no model is available.
+async function classifyControlMessage(input, status, { forcedIntent = null, llm = null, session = null } = {}) {
   // Caller (the /control message route) already trims and rejects empty input.
   const lower = String(input ?? '').toLowerCase();
   const intent = forcedIntent ? String(forcedIntent).toLowerCase() : null;
@@ -1377,22 +1448,53 @@ function classifyControlMessage(input, status, forcedIntent = null) {
   if (explicit) {
     return { kind: explicit, confidence: 1, reason: 'explicit_intent' };
   }
+  // Cancel stays a keyword: it is a runtime control verb, and an abort must not
+  // wait on a model round-trip.
   if (/\b(cancel|annule|stop|arr[eê]te|interromps|abort)\b/i.test(lower)) {
     return { kind: 'cancel', confidence: 0.86, reason: 'cancel_request' };
   }
   if (/\b(plus tard|later|ensuite|apr[eè]s ce run|enqueue|mets en file|met en file|futur|next run|future run)\b/i.test(lower)) {
     return { kind: 'enqueue_run', confidence: 0.8, reason: 'future_run_request' };
   }
-  if (/\b(o[uù] en es[t-]|status|statut|progress|progression|build|run|job|queue|file|logs?|explique|explain|inspect|show|montre|quoi de neuf)\b/i.test(lower)) {
+  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' };
   }
   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' };
   }
-  if (status.running && /\b(lance|run|g[eé]n[eè]re|build|export|cr[eé]e|create|send|envoie|ingest|convert|importe|import)\b/i.test(lower)) {
-    return { kind: 'ambiguous', confidence: 0.45, reason: 'active_run_action_is_ambiguous' };
+  if (!status.running) return { kind: 'converse', confidence: 0.62, reason: 'plain_conversation' };
+  // A run is active and none of the runtime control verbs matched. The message
+  // is either a request to perform a NEW mutating task (→ queue it to run
+  // after the current one) or ordinary conversation — that is a judgement about
+  // the workspace's domain, so the model decides it, never a keyword list.
+  if (llm && typeof llm.complete === 'function') {
+    try {
+      const reply = await llm.complete({
+        system: 'You classify one user message typed while a run is already active. Return exactly one word, nothing else.',
+        input: [
+          `The user typed this while a run is active: "${input}"`,
+          '',
+          'Choose ONE of:',
+          '- "action" — a request to perform a NEW task (generate, create, ingest, build, export, convert, send, publish, produce…), which must run after the current run.',
+          '- "conversation" — ordinary conversation, a question, or an unrelated remark.',
+          '',
+          'Return only that one word.',
+        ].join('\n'),
+        signal: AbortSignal.timeout(8_000),
+      });
+      const kind = String(reply ?? '').trim().toLowerCase();
+      if (kind.startsWith('action')) return { kind: 'enqueue_run', confidence: 0.85, reason: 'llm_classified_action' };
+      if (kind.startsWith('conversation')) return { kind: 'converse', confidence: 0.85, reason: 'llm_classified_conversation' };
+      emitRuntimeLog(session, `control-classify: LLM returned an unrecognized reply, falling back to the choice menu — ${JSON.stringify(kind).slice(0, 200)}`);
+    } catch (err) {
+      // A degradation must announce itself: silently falling through here
+      // hides the difference between "no LLM configured" (expected) and "the
+      // configured LLM is failing every call" (a real problem) — both would
+      // otherwise look identical from the Shell or serve UI.
+      emitRuntimeLog(session, `control-classify: LLM call failed, falling back to the choice menu — ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
-  return { kind: 'converse', confidence: 0.62, reason: 'plain_conversation' };
+  return { kind: 'ambiguous', confidence: 0.45, reason: 'action_vs_conversation_unclear' };
 }
 
 function isAuthorized(request, token) {

package/src/runtime/server.test.js

@@ -1434,10 +1434,14 @@ test('runtime server control message records active plan mutation as a proposal'
   }
 });
 
-test('runtime server control message reports ambiguity without starting a run', async (t) => {
+test('runtime server auto-queues a clear new action while a run is active', async (t) => {
   const session = {
     workspace: 'acme',
     controlQueue: [],
+    _onAgentEvent: () => {},
+    // The classifier asks the model whether the message is a new action; a
+    // keyword list is deliberately not part of the code path.
+    llm: { complete: async () => 'action' },
   };
   let runCount = 0;
   let handle;
@@ -1451,6 +1455,7 @@ test('runtime server control message reports ambiguity without starting a run',
           status: 'running',
           plan: [{ step: 1, description: 'Generate', status: 'running' }],
           queue: [],
+          controlQueue: session.controlQueue,
           approvals: [],
           summary: null,
         }),
@@ -1478,12 +1483,11 @@ test('runtime server control message reports ambiguity without starting a run',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ action: 'message', input: 'Lance aussi la publication' }),
     });
-    assert.equal(response.status, 200);
+    assert.equal(response.status, 202);
     const body = await response.json();
-    assert.equal(body.kind, 'ambiguous');
-    assert.equal(body.choices.length, 3);
-    assert.equal(session.controlQueue.length, 0);
-    assert.equal(runCount, 0);
+    assert.equal(body.kind, 'enqueue_run');
+    assert.equal(body.item.status, 'queued');
+    assert.equal(runCount, 0, 'the queued task must not start while the current run is active');
   } finally {
     await handle.close();
   }
@@ -1545,7 +1549,7 @@ test('runtime server drains queued control requests when idle', async (t) => {
     assert.match(receivedBody.runId, /^[0-9a-f-]{36}$/);
     assert.equal(session.controlQueue[0].status, 'running');
     assert.equal(session.controlQueue[0].runId, receivedBody.runId);
-    assert.deepEqual(events.map((event) => event.type), ['control_enqueued', 'control_started']);
+    assert.deepEqual(events.map((event) => event.type), ['control_enqueued', 'control_started', 'assistant_message']);
   } finally {
     await handle.close();
   }

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

@@ -202,7 +202,7 @@ test('E2E-003 cancel: the running step and its chain stop, unrelated queue survi
 // that silently fragments would show up as extra runs, not as extra objectives.
 const PERFORMANCE_TABLE = {
   pipeline: 1,
-  'wiki-ingest': 1,
+  'wiki-ingest': 2,
   'wiki-build': 1,
   deliver: 1,
   diagnose: 1,

package/src/shell/LeftPane.tsx

@@ -859,7 +859,7 @@ export function LeftPane(props: {
         above the composer keeps the current job in view while composing; the
         right pane keeps the full Plan/Queue/Logs detail.
       */}
-      <box flexShrink={0} height={4} flexDirection="column" overflow="hidden">
+      <box flexShrink={0} height={4} flexDirection="column" overflow="hidden" backgroundColor="#111318">
         <ActivityPanel activities={props.activities} width={props.width - 2} />
       </box>
       <ChatInput

package/src/shell/RightPane.tsx

@@ -20,7 +20,10 @@ type LogLineParts = { time: string | null; message: string };
 // 4 slots (was 6): items can now span up to 5 lines each (wrapped label +
 // wrapped status/error), so fewer, readable entries beat more, truncated ones.
 const ACTIVITY_SLOTS = Array.from({ length: 4 }, (_, index) => index);
-const PLAN_VIEWPORT_ROWS = 12;
+// Hauteur du panneau Plan : 6 lignes visibles au maximum. Les etapes suivantes
+// restent atteignables en faisant defiler la scrollbox (barre de defilement
+// affichee des que le plan depasse la fenetre).
+const PLAN_VIEWPORT_ROWS = 6;
 
 function wrapLine(value: string, width: number) {
   const max = Math.max(8, width);
@@ -194,12 +197,10 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
   // Keep one column for the native vertical scrollbar when the plan is long.
   const lineWidth = () => Math.max(8, props.width - 3);
   const firstPending = () => props.plan.find((s) => s.status === 'pending')?.step ?? null;
-  // A running step carries a thick left border, which costs one column: the
-  // wrap width is therefore one less for it. The same function feeds both the
-  // row-count memo and the render, so the viewport height can never undercount
-  // a running step's wrapped lines and clip the last one.
-  const isRunningStep = (step: PlanStep) => String(step.status ?? '').toLowerCase() === 'running';
-  const stepTextWidth = (step: PlanStep) => lineWidth() - (isRunningStep(step) ? 1 : 0);
+  // Plus de liseré bleu à gauche : l'icône et la couleur du texte suffisent à
+  // distinguer une étape en cours, et le cadre se voyait aussi sur une étape en
+  // attente (jaune). Toutes les étapes utilisent donc la même largeur.
+  const stepTextWidth = (_step: PlanStep) => lineWidth();
   const icon = (rawStatus: string) => {
     const status = String(rawStatus ?? '').toLowerCase();
     if (DONE_STATUSES.includes(status)) return '[✓]';
@@ -241,11 +242,10 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
           {(step) => {
             // Wrap step descriptions over up to 2 lines instead of truncating —
             // "Ingest des 39 documents raw/untrac…" hid the actual target.
-            const running = () => isRunningStep(step());
             const textWidth = () => stepTextWidth(step());
             const lines = () => wrapLine(`${icon(step().status)} ${step().step}. ${step().description}`, textWidth()).slice(0, 2);
             return (
-              <box flexShrink={0} flexDirection="column" border={running() ? ['left'] : undefined} borderStyle="heavy" borderColor="#89B4FA">
+              <box flexShrink={0} flexDirection="column">
                 <text width={textWidth()} fg={planStepColor(step(), firstPending())} content={lines()[0]} />
                 <Show when={lines()[1]}>
                   <text width={textWidth()} fg={planStepColor(step(), firstPending())} content={`    ${fit(lines()[1], Math.max(8, textWidth() - 4))}`} />
@@ -265,7 +265,7 @@ export function ActivityPanel(props: { activities: any[]; width: number }) {
   const visibleSlots = () => visible().map((_activity, index) => index);
   const activityAt = (index: number) => visible()[index] ?? null;
   return (
-    <box flexShrink={0} flexDirection="column" paddingX={1}>
+    <box flexShrink={0} flexDirection="column" paddingX={1} backgroundColor="#111318">
       <text width={lineWidth()} fg="#D6DEE8" content="Activity" />
       <Show when={visible().length > 0} fallback={<text width={lineWidth()} fg="#7F8C8D" content="no active jobs" />}>
         <Index each={visibleSlots()}>
@@ -385,7 +385,7 @@ export function LogPanel(props: { logs: string[]; width: number; filter?: string
     .filter((line) => activeLogTab() === 'agent-status' ? isAgentStatus(line) : !isAgentStatus(line));
   const allLines = createMemo(() => logRenderLines(filteredLogs(), lineWidth()));
   return (
-    <box flexGrow={2} flexDirection="column" paddingX={1} focusable={false}>
+    <box flexGrow={2} flexDirection="column" paddingX={1} marginTop={6} focusable={false}>
       <text width={lineWidth()} fg="#4B5563" content={'─'.repeat(lineWidth())} />
       <box height={1} flexDirection="row">
         <text