@dotdrelle/wiki-manager 0.11.4 → 0.11.7

package/src/runtime/runner.js

@@ -2,7 +2,7 @@ import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { activityKey, sessionActivities, terminalFailures } from '../core/activity.js';
 import { runAgenticLoop, throwIfAborted } from '../core/agentLoop.js';
 import { formatPlanStatus } from '../core/plan.js';
-import { formatReadyTaskPrompt, readyPlanTasks } from '../core/planPatch.js';
+import { formatReadyTaskPrompt, readyPlanTasks, sanitizePlanForExecution } from '../core/planPatch.js';
 import { emitRuntimeLog, pollActivitiesOnce } from './supervisor.js';
 
 const DEFAULT_MAX_REPLANS = 2;
@@ -92,6 +92,7 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
   let replansLeft = Math.max(0, Math.floor(Number(maxReplans) || 0));
 
   while (true) {
+    sanitizeSessionPlanForExecution(session, runId);
     const result = shouldUseParallelScheduler(session.headlessPlan)
       ? await runRuntimeParallelPlan(agent, session, input, {
         signal,
@@ -134,7 +135,9 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
       return { ok: false, result };
     }
 
-    const evaluation = await evaluateRuntimeRun(session, input, { runId, signal, evaluate });
+    const evaluation = session.headlessPlan
+      ? await evaluateRuntimeRun(session, input, { runId, signal, evaluate })
+      : null;
     if (evaluation) {
       dispatchAgentEvent(session, createAgentEvent('run_evaluated', {
         origin: 'runtime',
@@ -147,6 +150,19 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
         },
       }));
       if (!evaluation.ok) {
+        if (isUndefinedObjectiveEvaluation(evaluation)) {
+          dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+            origin: 'runtime',
+            runId,
+            payload: { content: clarificationMessageForEvaluation(evaluation) },
+          }));
+          dispatchAgentEvent(session, createAgentEvent('run_done', {
+            origin: 'runtime',
+            runId,
+            payload: { runId },
+          }));
+          return { ok: true, evaluation, clarified: true };
+        }
         if (replansLeft > 0) {
           const trigger = {
             kind: 'evaluation',
@@ -209,6 +225,7 @@ export async function runRuntimeParallelPlan(agent, session, input, {
     previousPlanUpdate?.();
     abortCancelledActiveTasks(session, active);
   };
+  sanitizeSessionPlanForExecution(session, runId);
   ensurePlanProjection(session, runId);
   emitRuntimeLog(session, `scheduler: parallel plan enabled (concurrency ${limit})`);
 
@@ -264,6 +281,20 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   }
 }
 
+function sanitizeSessionPlanForExecution(session, runId = null) {
+  if (!session.headlessPlan) return;
+  const sanitized = sanitizePlanForExecution(session.headlessPlan);
+  if (sanitized.warnings.length === 0) return;
+  session.headlessPlan = sanitized.plan;
+  dispatchAgentEvent(session, createAgentEvent('runtime_log', {
+    origin: 'runtime',
+    runId,
+    payload: {
+      message: `plan warning: ${sanitized.warnings.join('; ')}`,
+    },
+  }));
+}
+
 async function drainActive(active, locks) {
   if (active.size === 0) return;
   const entries = [...active.values()];
@@ -570,7 +601,9 @@ export async function finishRuntimeRun(session, input, {
   signal = null,
   evaluate = true,
 } = {}) {
-  const evaluation = await evaluateRuntimeRun(session, input, { runId, signal, evaluate });
+  const evaluation = session.headlessPlan
+    ? await evaluateRuntimeRun(session, input, { runId, signal, evaluate })
+    : null;
   if (evaluation) {
     dispatchAgentEvent(session, createAgentEvent('run_evaluated', {
       origin: 'runtime',
@@ -583,6 +616,19 @@ export async function finishRuntimeRun(session, input, {
       },
     }));
     if (!evaluation.ok) {
+      if (isUndefinedObjectiveEvaluation(evaluation)) {
+        dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+          origin: 'runtime',
+          runId,
+          payload: { content: clarificationMessageForEvaluation(evaluation) },
+        }));
+        dispatchAgentEvent(session, createAgentEvent('run_done', {
+          origin: 'runtime',
+          runId,
+          payload: { runId },
+        }));
+        return { ok: true, evaluation, clarified: true };
+      }
       dispatchAgentEvent(session, createAgentEvent('run_error', {
         origin: 'runtime',
         runId,
@@ -672,6 +718,21 @@ function normalizeEvaluation(value) {
   };
 }
 
+function isUndefinedObjectiveEvaluation(evaluation) {
+  const text = `${evaluation?.reason ?? ''} ${evaluation?.suggestedAction ?? ''}`
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '');
+  return /\b(vague|undefined|indefini|unclear|clarif|ambiguous|missing objective|no objective)\b/.test(text);
+}
+
+function clarificationMessageForEvaluation(evaluation) {
+  const reason = String(evaluation?.reason ?? '').trim();
+  return reason
+    ? `Je dois clarifier la demande avant d'agir : ${reason}`
+    : "Je dois clarifier la demande avant d'agir.";
+}
+
 function fallbackEvaluation(reason) {
   return {
     ok: true,
@@ -723,6 +784,10 @@ export async function replanRuntimeRun(session, input, trigger, {
         steps: mergedSteps,
       },
     }));
+    if (hasMutatingReplanStep(steps)) {
+      session._runApprovalRequired = true;
+      session._runApprovalResolved = false;
+    }
     return { ok: true, steps };
   } catch (err) {
     return { ok: false, reason: err instanceof Error ? err.message : String(err) };
@@ -811,6 +876,10 @@ function normalizeReplan(steps) {
     .slice(0, 12);
 }
 
+function hasMutatingReplanStep(steps) {
+  return steps.some((step) => /\b(build|copy|ingest|import|export|polish|pipeline|write|create|delete|update|send|deploy|publish|generate|construire|copier|importer|exporter|publier|envoyer|supprimer|modifier|creer|générer|generer)\b/i.test(step));
+}
+
 function mergeReplanWithCompleted(plan, steps) {
   const completed = (plan ?? [])
     .filter((step) => step.status === 'done')

package/src/runtime/runner.test.js

@@ -3,6 +3,41 @@ import test from 'node:test';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { finishRuntimeRun, replanRuntimeRun, runRuntimeAgenticWorkflow, runRuntimeParallelPlan } from './runner.js';
 
+test('runRuntimeAgenticWorkflow completes conversational turns without evaluation or replan', async () => {
+  const events = [];
+  const session = {
+    activities: {},
+    headlessPlan: null,
+    llm: {
+      async completeWithTools() {
+        assert.fail('conversation-only turn must not call evaluator or replanner');
+      },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+  const agent = {
+    async invoke() {
+      return { response: 'Salut.' };
+    },
+  };
+
+  const started = Date.now();
+  const result = await runRuntimeAgenticWorkflow(agent, session, 'salut', {
+    runId: 'run-chat',
+    timeoutMs: 1000,
+    maxTurns: 1,
+    maxReplans: 1,
+  });
+
+  assert.equal(result.ok, true);
+  assert.ok(Date.now() - started < 5000);
+  assert.equal(session.headlessPlan, null);
+  assert.equal(Object.keys(session.activities).length, 0);
+  assert.ok(events.some((event) => event.type === 'run_done'));
+  assert.equal(events.some((event) => event.type === 'run_evaluated'), false);
+  assert.equal(events.some((event) => event.type === 'run_replanned'), false);
+});
+
 test('finishRuntimeRun emits evaluation before run_done', async () => {
   const events = [];
   const session = {
@@ -33,6 +68,47 @@ test('finishRuntimeRun emits evaluation before run_done', async () => {
   assert.equal(session.agentProjection.status, 'done');
 });
 
+test('runRuntimeAgenticWorkflow clarifies vague evaluations without replan', async () => {
+  const events = [];
+  const session = {
+    activities: {},
+    headlessPlan: [{ step: 1, id: 'task', description: 'Task', status: 'done' }],
+    llm: {
+      async completeWithTools({ system }) {
+        assert.match(system, /strict evaluator/);
+        return { content: '{"ok":false,"reason":"demande vague / objectif indefini","suggestedAction":"clarifier l objectif"}' };
+      },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+  const agent = {
+    async invoke({ session: turnSession }) {
+      if (turnSession.headlessPlan === null) {
+        dispatchAgentEvent(turnSession, createAgentEvent('plan_set', {
+          origin: 'tool',
+          payload: { steps: [{ step: 1, id: 'task', description: 'Task', status: 'done' }] },
+        }));
+      }
+      return { response: 'Terminé.' };
+    },
+  };
+
+  const result = await runRuntimeAgenticWorkflow(agent, session, 'fais le truc', {
+    runId: 'run-vague',
+    timeoutMs: 1000,
+    maxTurns: 1,
+    maxReplans: 1,
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.clarified, true);
+  assert.ok(session.agentProjection.conversation.at(-1).content.includes('clarifier'));
+  assert.ok(events.some((event) => event.type === 'run_evaluated'));
+  assert.equal(events.some((event) => event.type === 'run_replanned'), false);
+  assert.equal(events.some((event) => event.type === 'tool_call_started'), false);
+  assert.equal(session.agentProjection.status, 'done');
+});
+
 test('finishRuntimeRun turns negative evaluation into run_error', async () => {
   const events = [];
   const session = {
@@ -62,7 +138,7 @@ test('finishRuntimeRun turns negative evaluation into run_error', async () => {
 test('finishRuntimeRun falls back open when evaluator response is invalid', async () => {
   const session = {
     activities: {},
-    headlessPlan: null,
+    headlessPlan: [{ step: 1, description: 'Do work', status: 'done' }],
     agentProjection: { conversation: [] },
     llm: {
       async completeWithTools() {
@@ -126,13 +202,20 @@ test('runRuntimeAgenticWorkflow replans after negative evaluation', async () =>
   const agent = {
     async invoke({ session: turnSession }) {
       turns += 1;
+      if (turnSession.headlessPlan === null) {
+        dispatchAgentEvent(turnSession, createAgentEvent('plan_set', {
+          origin: 'tool',
+          payload: { steps: [{ step: 1, id: 'initial', description: 'Initial work', status: 'done' }] },
+        }));
+        return { response: 'Initial done.' };
+      }
       if (turnSession.headlessPlan?.[0]?.status === 'pending') {
         dispatchAgentEvent(turnSession, createAgentEvent('plan_step_updated', {
           origin: 'tool',
           payload: { step: 1, status: 'done' },
         }));
       }
-      return { response: turns === 1 ? 'Initial done.' : 'Export done.' };
+      return { response: 'Export done.' };
     },
   };
 
@@ -175,6 +258,27 @@ test('replanRuntimeRun preserves completed outputs when replacing remaining work
   assert.deepEqual(session.headlessPlan[1].dependsOn, ['export']);
 });
 
+test('replanRuntimeRun requires runtime approval for mutating replanned work', async () => {
+  const session = {
+    activities: {},
+    headlessPlan: [{ step: 1, id: 'build', description: 'Build', status: 'failed' }],
+    llm: {
+      async completeWithTools() {
+        return { content: '{"steps":["Run production build"]}' };
+      },
+    },
+  };
+
+  const result = await replanRuntimeRun(session, 'Build deliverable', {
+    kind: 'evaluation',
+    reason: 'Build missing.',
+  }, { runId: 'run-replan-approval', replansLeft: 1 });
+
+  assert.equal(result.ok, true);
+  assert.equal(session._runApprovalRequired, true);
+  assert.equal(session._runApprovalResolved, false);
+});
+
 test('runRuntimeAgenticWorkflow replans after terminal activity error', async () => {
   const originalFetch = globalThis.fetch;
   let pollAttempts = 0;
@@ -276,7 +380,13 @@ test('runRuntimeAgenticWorkflow stops after replan budget is exhausted', async (
     },
   };
   const agent = {
-    async invoke() {
+    async invoke({ session: turnSession }) {
+      if (turnSession.headlessPlan === null) {
+        dispatchAgentEvent(turnSession, createAgentEvent('plan_set', {
+          origin: 'tool',
+          payload: { steps: [{ step: 1, id: 'task', description: 'Task', status: 'done' }] },
+        }));
+      }
       return { response: 'Done.' };
     },
   };

package/src/runtime/server.js

@@ -18,6 +18,7 @@ export function startRuntimeServer({
   approve,
   configProfiles,
   useConfigProfile,
+  exitOnShutdown = process.env.WIKI_MANAGER_RUNTIME_CHILD === '1',
 } = {}) {
   const clients = new Set();
   const defaultContext = { workspace: null, session, running: false, currentAbortController: null, currentRunId: null };
@@ -31,6 +32,13 @@ export function startRuntimeServer({
     }
   }
 
+  function publishState(workspace = null, context = null) {
+    for (const client of clients) {
+      if (client.workspace && client.workspace !== workspace) continue;
+      client.response.write(`event: state\ndata: ${JSON.stringify(runtimeState(context, store, { workspace, session }))}\n\n`);
+    }
+  }
+
   const server = createServer(async (request, response) => {
     try {
       if (!isAuthorized(request, token)) {
@@ -223,6 +231,23 @@ export function startRuntimeServer({
         sendJson(response, 202, { cancelled: true, workspace: context.workspace ?? workspace ?? null });
         return;
       }
+      if (request.method === 'POST' && url.pathname === '/shutdown') {
+        const workspace = workspaceFromUrl(url);
+        const context = await resolveContext({ workspace });
+        if (context?.running && context.currentAbortController) {
+          context.currentAbortController.abort();
+          await cancel?.(context);
+        }
+        sendJson(response, 202, { shutdown: true });
+        setImmediate(() => {
+          for (const client of clients) client.response.end();
+          clients.clear();
+          server.close(() => {
+            if (exitOnShutdown) process.exit(0);
+          });
+        });
+        return;
+      }
       if (request.method === 'POST' && url.pathname === '/resume') {
         const workspace = workspaceFromUrl(url);
         const result = await resume?.({ workspace });
@@ -307,6 +332,7 @@ export function startRuntimeServer({
         context.currentAbortController = null;
         context.currentRunId = null;
         context.currentRunWorkspace = null;
+        publishState(runWorkspace, context);
         void startNextControlRequest(context);
       });
     return { accepted: true, runId, workspace: runWorkspace };
@@ -610,7 +636,7 @@ function classifyControlMessage(input, status, forcedIntent = null) {
   if (['observe', 'converse', 'mutate', 'enqueue'].includes(intent)) {
     return { kind: intent, confidence: 1, reason: 'explicit_intent' };
   }
-  if (/\b(o[uù] en est|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|build|run|job|queue|file|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)) {

package/src/runtime/server.test.js

@@ -46,6 +46,44 @@ test('runtime server checks bearer and x-runtime-token credentials', async (t) =
   }
 });
 
+test('runtime server shutdown endpoint closes the listener', async (t) => {
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      token: 'runtime-secret',
+      exitOnShutdown: false,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      session: {},
+      run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  const url = `http://127.0.0.1:${handle.port}`;
+  const response = await fetch(`${url}/shutdown`, {
+    method: 'POST',
+    headers: { authorization: 'Bearer runtime-secret' },
+  });
+  assert.equal(response.status, 202);
+  assert.equal((await response.json()).shutdown, true);
+
+  await new Promise((resolve) => setTimeout(resolve, 20));
+  await assert.rejects(fetch(`${url}/health`, {
+    headers: { authorization: 'Bearer runtime-secret' },
+  }));
+});
+
 test('runtime server accepts only one active run', async (t) => {
   let releaseRun;
   let runCount = 0;

package/src/shell/LeftPane.tsx

@@ -662,6 +662,7 @@ export function LeftPane(props: {
 }) {
   const modeColor = () => props.chatMode ? '#22C55E' : '#06B6D4';
   const modeLabel = () => props.chatMode ? 'CHAT MODE  direct LLM, no tools' : 'AGENTIC MODE  LangGraph + MCP tools';
+  const showWelcome = () => props.showWelcome && props.messages.length === 0;
   return (
     <box width={props.width} height="100%" flexDirection="column" padding={1} overflow="hidden">
       <box height={3} flexDirection="column">
@@ -676,7 +677,7 @@ export function LeftPane(props: {
           {props.hintLine ? <text fg="#FBBF24">[ {props.hintLine} ]</text> : null}
         </box>
       </box>
-      {props.showWelcome ? (
+      {showWelcome() ? (
         <WelcomeHelpPanels width={props.conversationColumns} />
       ) : (
         <ConversationView

package/src/shell/StartupScreen.tsx

@@ -1,6 +1,5 @@
 /** @jsxImportSource @opentui/solid */
-import { useKeyboard } from '@opentui/solid';
-import { createMemo, createSignal, For } from 'solid-js';
+import { createEffect, createMemo, createSignal, For, untrack } from 'solid-js';
 import { fit } from './textFit';
 
 export type StartupAction =
@@ -15,6 +14,15 @@ type StartupItem = {
   detail: string;
 };
 
+const DONNA_LOGO = `
+██████╗  ██████╗ ███╗   ██╗███╗   ██╗ █████╗
+██╔══██╗██╔═══██╗████╗  ██║████╗  ██║██╔══██╗
+██║  ██║██║   ██║██╔██╗ ██║██╔██╗ ██║███████║
+██║  ██║██║   ██║██║╚██╗██║██║╚██╗██║██╔══██║
+██████╔╝╚██████╔╝██║ ╚████║██║ ╚████║██║  ██║
+╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═══╝╚═╝  ╚═╝
+`.trim();
+
 function statusDot(ready: boolean) {
   return ready ? '●' : '○';
 }
@@ -23,6 +31,58 @@ function initWorkspaceItem(detail: string): StartupItem {
   return { action: 'init-workspace', label: 'Initialize workspace', detail };
 }
 
+function keyNameOf(key: any) {
+  return String(key?.name ?? key?.key ?? '').toLowerCase();
+}
+
+function keySequenceOf(key: any) {
+  return String(key?.sequence ?? key?.raw ?? key?.seq ?? key?.input ?? '');
+}
+
+function isEnterKey(key: any) {
+  const keyName = keyNameOf(key);
+  const sequence = keySequenceOf(key);
+  return Boolean(
+    key?.return ||
+    key?.enter ||
+    key?.linefeed ||
+    keyName === 'return' ||
+    keyName === 'enter' ||
+    keyName === 'linefeed' ||
+    keyName === 'kpenter' ||
+    keyName === 'keypadenter' ||
+    keyName === 'numenter' ||
+    (key?.ctrl && keyName === 'm') ||
+    sequence === '\r' ||
+    sequence === '\n' ||
+    sequence === '\r\n' ||
+    sequence === '\x1bOM' ||
+    /^\x1b\[13(?:;\d+)?u$/.test(sequence),
+  );
+}
+
+function isEscapeKey(key: any) {
+  const keyName = keyNameOf(key);
+  return keyName === 'escape' || keySequenceOf(key) === '\x1b';
+}
+
+function isUpKey(key: any) {
+  const keyName = keyNameOf(key);
+  const sequence = keySequenceOf(key);
+  return keyName === 'up' || keyName === 'arrow_up' || sequence === '\x1b[A' || /^\x1b\[57352(?:;\d+)?u$/.test(sequence);
+}
+
+function isDownKey(key: any) {
+  const keyName = keyNameOf(key);
+  const sequence = keySequenceOf(key);
+  return keyName === 'down' || keyName === 'arrow_down' || sequence === '\x1b[B' || /^\x1b\[57353(?:;\d+)?u$/.test(sequence);
+}
+
+function consumeKey(key: any) {
+  key?.preventDefault?.();
+  key?.stopPropagation?.();
+}
+
 export function StartupScreen(props: {
   version: string;
   model: string;
@@ -34,13 +94,15 @@ export function StartupScreen(props: {
   hasWorkspace: boolean;
   width: number;
   height: number;
+  keyboardEvent?: { id: number; key: any } | null;
   onSelect: (action: StartupAction, workspaceName?: string) => void;
   onQuit: () => void;
 }) {
   const [mode, setMode] = createSignal<'home' | 'workspace-select'>('home');
   const [selected, setSelected] = createSignal(0);
-  const panelWidth = createMemo(() => Math.max(54, Math.min(86, props.width - 4)));
-  const panelHeight = createMemo(() => Math.max(24, Math.min(32, props.height - 2)));
+  let lastKeyboardEventId = 0;
+  const panelWidth = createMemo(() => Math.max(70, Math.min(96, props.width - 4)));
+  const panelHeight = createMemo(() => Math.max(27, Math.min(35, props.height - 2)));
   const left = createMemo(() => Math.max(1, Math.floor((props.width - panelWidth()) / 2)));
   const top = createMemo(() => Math.max(1, Math.floor((props.height - panelHeight()) / 2)));
 
@@ -74,9 +136,23 @@ export function StartupScreen(props: {
   const currentLength = createMemo(() => mode() === 'workspace-select' ? workspaceItems().length : items().length);
 
   const move = (delta: number) => {
-    setSelected((value) => (value + delta + currentLength()) % currentLength());
+    const length = currentLength();
+    if (length <= 0) {
+      setSelected(0);
+      return;
+    }
+    setSelected((value) => (value + delta + length) % length);
   };
 
+  createEffect(() => {
+    const length = currentLength();
+    if (length <= 0) {
+      setSelected(0);
+      return;
+    }
+    if (selected() >= length) setSelected(length - 1);
+  });
+
   const choose = (index = selected()) => {
     if (mode() === 'workspace-select') {
       const item = workspaceItems()[index];
@@ -93,38 +169,52 @@ export function StartupScreen(props: {
     props.onSelect(item.action);
   };
 
-  useKeyboard((key: any) => {
-    const keyName = String(key.name ?? '').toLowerCase();
-    const sequence = String(key.sequence ?? '');
+  const handleKey = (key: any) => {
+    const keyName = keyNameOf(key);
+    const sequence = keySequenceOf(key);
     if ((key.ctrl || key.meta) && keyName === 'c') {
+      consumeKey(key);
       props.onQuit();
       return;
     }
-    if (keyName === 'escape' && mode() === 'workspace-select') {
+    if (isEscapeKey(key) && mode() === 'workspace-select') {
+      consumeKey(key);
       setMode('home');
       setSelected(0);
       return;
     }
-    if (keyName === 'escape') {
+    if (isEscapeKey(key)) {
+      consumeKey(key);
       props.onQuit();
       return;
     }
-    if (keyName === 'up') {
-      move(-1);
+    if (isEnterKey(key)) {
+      consumeKey(key);
+      choose();
       return;
     }
-    if (keyName === 'down') {
-      move(1);
+    if (isUpKey(key)) {
+      consumeKey(key);
+      move(-1);
       return;
     }
-    if (keyName === 'return' || keyName === 'enter') {
-      choose();
+    if (isDownKey(key)) {
+      consumeKey(key);
+      move(1);
       return;
     }
     const numeric = Number.parseInt(sequence, 10);
     if (Number.isInteger(numeric) && numeric >= 1 && numeric <= currentLength()) {
+      consumeKey(key);
       choose(numeric - 1);
     }
+  };
+
+  createEffect(() => {
+    const event = props.keyboardEvent;
+    if (!event || event.id === lastKeyboardEventId) return;
+    lastKeyboardEventId = event.id;
+    untrack(() => handleKey(event.key));
   });
 
   const status = createMemo(() => {
@@ -144,7 +234,7 @@ export function StartupScreen(props: {
     const quick = count === 1 ? '1 quick select' : `1-${count} quick select`;
     return mode() === 'workspace-select'
       ? `↑/↓ select  Enter open  ${quick}  Esc back`
-      : `↑/↓ select  Enter open  ${quick}  Esc quit`;
+      : `↑/↓ select  Enter choose  ${quick}  Esc quit`;
   });
   const menuTitle = createMemo(() => mode() === 'workspace-select' ? 'Select workspace' : '');
 
@@ -170,12 +260,17 @@ export function StartupScreen(props: {
         </box>
         <text height={1} fg="#7F8C8D" content={fit(subtitle(), innerWidth())} />
         <text height={1}>{''}</text>
-        <text height={1} fg="#D6DEE8">██████╗  ██████╗ ███╗   ██╗███╗   ██╗ █████╗</text>
-        <text height={1} fg="#D6DEE8">██╔══██╗██╔═══██╗████╗  ██║████╗  ██║██╔══██╗</text>
-        <text height={1} fg="#D6DEE8">██║  ██║██║   ██║██╔██╗ ██║██╔██╗ ██║███████║</text>
-        <text height={1} fg="#D6DEE8">██║  ██║██║   ██║██║╚██╗██║██║╚██╗██║██╔══██║</text>
-        <text height={1} fg="#D6DEE8">██████╔╝╚██████╔╝██║ ╚████║██║ ╚████║██║  ██║</text>
-        <text height={1} fg="#D6DEE8">╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═══╝╚═╝  ╚═╝</text>
+        <box
+          height={8}
+          flexDirection="column"
+          justifyContent="center"
+          alignItems="center"
+          gap={1}
+          overflow="hidden"
+        >
+          <text fg="#d6a85f">{DONNA_LOGO}</text>
+          <text fg="#888888">Intelligent workspace</text>
+        </box>
         <text height={1}>{''}</text>
         <text height={1} fg="#7F8C8D" content={menuTitle()} />
         <box height={Math.max(1, currentLength())} flexDirection="column">