@dotdrelle/wiki-manager 0.12.1 → 0.12.7

package/src/shell/repl.test.js

@@ -11,6 +11,7 @@ import {
   runLine,
   runtimeStatusLine,
   runtimeUnavailableAgentMessage,
+  shouldHandleFreeTextLocally,
   submitRuntimeRun,
 } from './repl.js';
 
@@ -81,7 +82,9 @@ test('submitRuntimeRun reports acceptance without throwing', async () => {
   try {
     const session = createSession();
     const outcome = await submitRuntimeRun('build the doc', { runtime: { url: 'http://runtime.test' }, session });
-    assert.deepEqual(outcome, { kind: 'accepted' });
+    // The accepted payload is passed through so callers can surface the runId
+    // in the chat (immediate feedback that the run started).
+    assert.deepEqual(outcome, { kind: 'accepted', result: { accepted: true, runId: 'run-1' } });
   } finally {
     restore();
   }
@@ -191,3 +194,113 @@ test('runtime status exposes the disconnected reason', () => {
     '⚠ Runtime indisponible : token mismatch — /agent désactivé, /chat reste possible',
   );
 });
+
+test('/run kill posts to the runtime kill endpoint', async () => {
+  let calledUrl = null;
+  const restore = stubFetch(async (url) => {
+    calledUrl = new URL(String(url));
+    return jsonResponse(202, { killed: true, runs: 1, tasks: 2 });
+  });
+  try {
+    const session = createSession();
+    session.workspace = 'docs';
+
+    const result = await runLine('/run kill', {
+      agent: null,
+      packageJson: { version: 'test' },
+      session,
+      runtime: { url: 'http://runtime.test' },
+    });
+
+    assert.equal(result.exit, false);
+    assert.equal(calledUrl.pathname, '/kill');
+    assert.equal(calledUrl.searchParams.get('workspace'), 'docs');
+    assert.match(conversationMessages(session).at(-1).content, /Runtime kill requested: 1 run, 2 tasks cancelled/);
+  } finally {
+    restore();
+  }
+});
+
+test('/queue cancel on a runtime workflow id points to run cancellation commands', async () => {
+  const session = createSession();
+  session.workspace = 'docs';
+  session.jobQueue = [];
+  session.workflow = {
+    nodes: [{ id: 'task:runtime-a', type: 'task', label: 'Runtime task', status: 'pending' }],
+    relations: [],
+  };
+
+  const result = await runLine('/queue cancel task:runtime-a', {
+    agent: null,
+    packageJson: { version: 'test' },
+    session,
+  });
+
+  assert.equal(result.exit, false);
+  assert.match(conversationMessages(session).at(-1).content, /Item géré par le runtime/);
+  assert.match(conversationMessages(session).at(-1).content, /\/run kill/);
+});
+
+test('free text routing keeps questions local and sends actions to the runtime', () => {
+  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');
+
+  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');
+});
+
+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.
+  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);
+
+  const offline = createSession();
+  offline.llm = null;
+  const fallback = shouldHandleFreeTextLocally('donne moi la config du cme', offline);
+  assert.equal(fallback.local, false);
+  assert.match(fallback.fallbackReason ?? '', /LLM unavailable/);
+});
+
+test('submitRuntimeRun sends a control message instead of /run while a run is active', async () => {
+  const paths = [];
+  const restore = stubFetch(async (url) => {
+    paths.push(pathOf(url));
+    return jsonResponse(200, {
+      accepted: true,
+      kind: 'cancel',
+      classification: { kind: 'cancel' },
+      explanation: 'Runtime cancellation requested.',
+    });
+  });
+  try {
+    const session = createSession();
+    session.agentProjection = { status: 'running', activities: [], conversation: [] };
+    const outcome = await submitRuntimeRun('stop le job', { runtime: { url: 'http://runtime.test' }, session });
+    assert.deepEqual(paths, ['/control'], 'active run must use the control lane, not POST /run');
+    assert.equal(outcome.kind, 'cancel');
+    assert.match(outcome.result?.explanation ?? '', /cancellation requested/i);
+  } finally {
+    restore();
+  }
+});

package/src/shell/tui.tsx

@@ -126,7 +126,10 @@ function App(props: {
   const conversationRows = createMemo(() => Math.max(4, dimensions().height - 5 - chatInputHeight()));
   const rightColumns = createMemo(() => {
     const width = dimensions().width;
-    return Math.max(26, Math.min(44, Math.floor(width * 0.32)));
+    // 38% / cap 56 (was 32% / cap 44): the Plan/Activity/Logs panes carry job
+    // labels, file names and error messages — 40 columns truncated everything
+    // into unreadable stubs.
+    return Math.max(30, Math.min(56, Math.floor(width * 0.38)));
   });
   const leftColumns = createMemo(() => Math.max(32, dimensions().width - rightColumns() - 1));
   const conversationColumns = createMemo(() => {

package/src/shell/useAgent.ts

@@ -1,6 +1,6 @@
 import { createSignal } from 'solid-js';
 import { postRuntimeCancel } from '../runtime/client.js';
-import { conversationMessages, recordRuntimeUnavailableAgentInput, runLine, submitRuntimeRun } from './repl.js';
+import { conversationMessages, recordRuntimeUnavailableAgentInput, runLine, shouldHandleFreeTextLocally, submitRuntimeRun } from './repl.js';
 
 export function useAgent(props: { agent: unknown; packageJson: Record<string, unknown>; session: Record<string, any>; chatMode: () => boolean; runtimeUrl?: string | null; runtimeUnavailableReason?: string | null; refresh: () => void; addLog: (line: string) => void; onRuntimeAccepted?: () => void }) {
   const [busy, setBusy] = createSignal(false);
@@ -18,7 +18,17 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
     props.addLog(`input: ${trimmed}`);
 
     try {
-      if (props.runtimeUrl && !props.chatMode() && !trimmed.startsWith('/')) {
+      // Questions and small talk are answered by the local agent: the reply
+      // shows up in the chat immediately and no runtime run (plan, SQLite
+      // state, replans) is created for a sentence that only needed an answer.
+      // Actions still go to the runtime below.
+      const freeTextRouting = (props.runtimeUrl && !props.chatMode() && !trimmed.startsWith('/'))
+        ? shouldHandleFreeTextLocally(trimmed, props.session)
+        : null;
+      if (props.runtimeUrl && !props.chatMode() && !trimmed.startsWith('/') && !freeTextRouting?.local) {
+        if (freeTextRouting?.fallbackReason) {
+          props.addLog(`runtime: ${freeTextRouting.fallbackReason}, routing to runtime run`);
+        }
         // Marked _pending so mergeRuntimeConversation (useSession.ts) can
         // confirm this exact entry instead of pushing a second copy once the
         // same user message comes back from the runtime's own /state.
@@ -29,6 +39,13 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
         });
         if (outcome.kind === 'accepted') {
           props.onRuntimeAccepted?.();
+          const runId = (outcome as any).result?.runId ?? null;
+          // Light, immediate feedback in the chat: without it an accepted run
+          // is invisible until its first activity lands in the side panels.
+          conversationMessages(props.session).push({
+            role: 'command',
+            content: `▶ Run accepté${runId ? ` (${String(runId).slice(0, 8)})` : ''} — progression dans le panneau Activity, réponse ici à la fin du run.`,
+          });
           props.addLog('runtime: run accepted');
         } else if (outcome.kind === 'queued') {
           // The server localizes control-lane acknowledgements from the
@@ -37,6 +54,11 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
           const explanation = (outcome as any).result?.explanation ?? 'Request added to the queue.';
           conversationMessages(props.session).push({ role: 'command', content: String(explanation) });
           props.addLog('runtime: control queued');
+        } else if ((outcome as any).result?.explanation) {
+          // Control-lane kinds (cancel / approve / observe / modify_run…):
+          // surface the server's localized explanation instead of an error.
+          conversationMessages(props.session).push({ role: 'command', content: String((outcome as any).result.explanation) });
+          props.addLog(`runtime: ${outcome.kind}`);
         } else {
           conversationMessages(props.session).push({ role: 'command', content: `Runtime error: ${outcome.message}` });
           props.addLog(`runtime error: ${outcome.message}`);
@@ -44,7 +66,7 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
         props.refresh();
         return { exit: false, runtime: true };
       }
-      if (!props.chatMode() && !trimmed.startsWith('/')) {
+      if (!props.chatMode() && !trimmed.startsWith('/') && !freeTextRouting?.local) {
         const message = recordRuntimeUnavailableAgentInput(props.session, trimmed, {
           error: props.runtimeUnavailableReason ?? 'runtime introuvable',
         });
@@ -52,6 +74,9 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
         props.refresh();
         return { exit: false, runtimeUnavailable: true };
       }
+      if (freeTextRouting?.local) {
+        props.addLog(`agent: ${freeTextRouting.classification.kind} handled locally`);
+      }
       const result = await runLine(trimmed, {
         agent: props.agent,
         packageJson: props.packageJson,
@@ -59,6 +84,10 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
         onUpdate: props.refresh,
         onStep: props.addLog,
         chatMode: props.chatMode(),
+        // Without this, slash commands that target the runtime (/run kill,
+        // /run cancel, /run status) reported "Runtime unavailable" in the
+        // TUI even while the status bar showed "runtime: connected".
+        runtime: props.runtimeUrl ? { url: props.runtimeUrl } : null,
       });
       props.refresh();
       return result;

package/src/shell/useSession.ts

@@ -2,6 +2,7 @@ import { writeFileSync } from 'node:fs';
 import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
 import { formatMcpToolResult, callMcpTool } from '../core/mcp.js';
+import { versionWithBuild } from '../core/buildInfo.js';
 import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { formatPlanStatus, formatCompletedActivities, formatPlanStep } from '../core/plan.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
@@ -47,6 +48,12 @@ function buildContinuationPrompt(session: any, completed: any[]): string {
 
 export function useSession(props: { agent: unknown; packageJson: Record<string, unknown>; runtime?: any }) {
   const session = createSession();
+  // Donna's runtime__kill/cancel/status/approve/enqueue tools (graph.js)
+  // read session.runtime.url directly — without this the OpenTUI session
+  // never had it set (only the legacy runShell path did), so those tools
+  // reported "Runtime not connected" even with the runtime up and the
+  // status bar showing "connected".
+  (session as any).runtime = props.runtime ?? null;
   const [version, setVersion] = createSignal(0);
   const [logs, setLogs] = createSignal<string[]>([]);
   const [runtimeState, setRuntimeState] = createSignal<any | null>(null);
@@ -139,7 +146,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   const statusLine = createMemo(() => {
     version();
     return [
-      `wiki-manager ${props.packageJson.version ?? ''}`.trim(),
+      `wiki-manager ${versionWithBuild(props.packageJson)}`.trim(),
       session.workspace ? session.workspace : 'no workspace',
       session.wikirc?.profile ? session.wikirc.profile : 'no wikirc',
       session.language ? session.language : 'no language',
@@ -337,6 +344,12 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     const target = conversationMessages(session);
     const backed = runtimeConversationRefsByWorkspace.get(workspace) ?? [];
     runtimeConversationRefsByWorkspace.set(workspace, backed);
+    // 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
+    // backed entry instead of appearing in the chat. Drop the refs and let
+    // the new conversation append cleanly.
+    if (runtimeConversation.length < backed.length) backed.length = 0;
     if (backed.length === 0 && target.length === 0 && !runtimeConversation.some((message: any) => message?._pending)) {
       backed.push(...runtimeConversation.map((message: any) => ({
         role: message.role === 'assistant' ? 'donna' : message.role,