@dotdrelle/wiki-manager 0.11.6 → 0.11.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.11.6",
+  "version": "0.11.7",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",

package/src/agent/graph.js

@@ -1,3 +1,4 @@
+import { join } from 'node:path';
 import { Annotation, END, START, StateGraph } from '@langchain/langgraph';
 import {
   buildLlmTools,
@@ -6,45 +7,17 @@ import {
   formatMcpToolsForAgent,
   parseToolCallName,
 } from '../core/mcp.js';
-import { formatSkillsForAgent } from '../core/skills.js';
+import { formatSkillsForAgent, readOptionalText } from '../core/skills.js';
 import { handleSlashCommand } from '../commands/slash.js';
 import { extractActivity, formatActivitySummary, parseJsonText } from '../core/activity.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { enqueueProductionJob, ensureJobQueue, formatQueue, productionLockBusy } from '../core/jobQueue.js';
+import { updateWorkspaceProfilePreference } from '../core/profile.js';
 
 const MAX_TOOL_ITERATIONS = 80;
 const MAX_SPINNER_ARG_LENGTH = 96;
+const MAX_PROFILE_CHARS = 4000;
 
-// Deterministic guard: on the first turn of a fresh /agent input, only bind
-// job-starting/mutating MCP tools when the raw text actually looks like an
-// action request. Plain chat (greetings, thanks, small talk) never sees those
-// tools bound, so the LLM cannot start a production job/plan from a "salut" —
-// prompting alone was not reliable enough (see plan-directeur history).
-const ACTION_INTENT_RE = /\b(lance|lancer|lancez|d[ée]marre|d[ée]marrer|d[ée]marrez|ex[ée]cute|ex[ée]cuter|exporte|exporter|export|importe|importer|import|g[ée]n[èe]re|g[ée]n[ée]rer|g[ée]n[ée]ration|cr[ée]e|cr[ée]er|construis|build|run|start|launch|deploy|d[ée]ploie|d[ée]ployer|d[ée]ploiement|publie|publier|publish|publication|synchronise|synchroniser|sync|convertis|convertir|convert|envoie|envoyer|send|configure|configurer|ajoute|ajouter|add|planifie|planifier|schedule|ingest|ing[èe]re|ing[èe]rer|ingestion|polish|pipeline|skill|job|t[âa]che|workflow|refais|relance|retente|retry)\b/i;
-const READ_ONLY_TOOL_NAME_RE = /(^|_)(list|status|get|read|describe|show|search|find)(_|$)/i;
-
-function isReadOnlyToolName(name) {
-  return READ_ONLY_TOOL_NAME_RE.test(String(name ?? ''));
-}
-
-function filterToolsForChatOnlyTurn(tools) {
-  return [
-    SHELL_READ_COMMAND_TOOL,
-    ...tools.filter((tool) => isReadOnlyToolName(tool?.function?.name ?? '')),
-  ];
-}
-
-function toolsForDonnaTurn(input, tools, iterations) {
-  if (iterations !== 0) return tools;
-  const text = String(input ?? '');
-  if (ACTION_INTENT_RE.test(text)) return tools;
-  // Plain chat (no action, no read intent) still gets the minimal read-only
-  // set, never an empty array: the system prompt unconditionally describes
-  // the connected MCP tools regardless of what's actually bound this turn,
-  // and sending zero tools while the prompt talks about them confuses some
-  // models into an empty/malformed completion instead of a plain reply.
-  return filterToolsForChatOnlyTurn(tools);
-}
 const AGENT_SLASH_COMMANDS = new Set([
   'help',
   'version',
@@ -105,6 +78,28 @@ const SHELL_READ_COMMAND_TOOL = {
   },
 };
 
+const SHELL_PROFILE_UPDATE_TOOL = {
+  type: 'function',
+  function: {
+    name: 'shell__profile_update',
+    description: [
+      'Append one explicit durable user preference to the current workspace .wiki/profile.md.',
+      'Use when the user explicitly asks to remember, persist, note, or update profile information and wiki__profile_update is not available.',
+    ].join(' '),
+    parameters: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        preference: {
+          type: 'string',
+          description: 'The durable preference to append, without Markdown bullet syntax.',
+        },
+      },
+      required: ['preference'],
+    },
+  },
+};
+
 const WIKI_PLAN_SET_TOOL = {
   type: 'function',
   function: {
@@ -510,6 +505,18 @@ function selectExecutorForStep(description, session) {
   return fallback;
 }
 
+// The manager runs on the same host filesystem as the workspace directory
+// (this is the same local file wiki__profile_update writes to via its
+// volume-mounted container), so read it fresh on every turn instead of
+// relying on the model proactively calling wiki__profile_read — profile
+// content (tutoiement, formatting preferences, etc.) is meant to shape every
+// reply, not just ones where the model happens to think to check it.
+function loadWorkspaceProfile(workspacePath) {
+  if (!workspacePath) return null;
+  const content = readOptionalText(join(workspacePath, '.wiki', 'profile.md'));
+  return content ? content.slice(0, MAX_PROFILE_CHARS) : null;
+}
+
 export function buildAgentSystemPrompt(state) {
   const workspace = state.session.workspace ?? 'no workspace selected';
   const wikirc = state.session.wikirc?.profile ?? 'no profile loaded';
@@ -517,6 +524,7 @@ export function buildAgentSystemPrompt(state) {
   const mcpTools = formatMcpToolsForAgent(state.session.mcp);
   const skills = formatSkillsForAgent(state.session);
   const customPrompt = state.session.systemPrompt ?? null;
+  const workspaceProfile = loadWorkspaceProfile(state.session.workspacePath);
 
   const agentContext = [
     'You are Donna, the terminal orchestrator agent for llm-wiki-manager.',
@@ -576,7 +584,11 @@ export function buildAgentSystemPrompt(state) {
     'If production_start_job is returned as queued/waiting by the manager, report that it is waiting in the local queue and return control. Do not continue as if the production job has started.',
     'For diagnostics, use /wiki run doctor when the user asks for doctor. Use /workspace init <name> [path] for low-level non-interactive workspace creation. In the interactive TUI, /new <name> opens the setup wizard. Use /wiki for index, or /wiki run index through the explicit backup hatch. Use /wiki run init only for explicit current-workspace llm-wiki init.',
     'If an action requires tools or skills not available yet, explain the limitation and name the expected primitive.',
-  ].join('\n');
+    workspaceProfile
+      ? `Workspace profile (.wiki/profile.md) — durable user preferences, apply these to every reply (tone, tutoiement/vouvoiement, formatting, etc.):\n${workspaceProfile}`
+      : null,
+    'When the user explicitly asks you to remember, persist, or update durable preference/profile information, call wiki__profile_update when it is available; otherwise call shell__profile_update. Do not just acknowledge in text without calling a profile update tool.',
+  ].filter(Boolean).join('\n');
 
   return customPrompt ? `${customPrompt}\n\n${agentContext}` : agentContext;
 }
@@ -630,11 +642,13 @@ export function createAgentGraph(options = {}) {
 
     const allTools = [
       SHELL_RUN_COMMAND_TOOL,
+      SHELL_READ_COMMAND_TOOL,
+      SHELL_PROFILE_UPDATE_TOOL,
       WIKI_PLAN_SET_TOOL,
       WIKI_PLAN_DONE_TOOL,
       ...buildLlmTools(state.session.mcp),
     ];
-    const tools = toolsForDonnaTurn(state.input, allTools, iterations);
+    const tools = allTools;
     const system = buildAgentSystemPrompt(state);
 
     // On iteration 0: prior history is in state.messages, user input must be appended.
@@ -759,6 +773,9 @@ export function createAgentGraph(options = {}) {
           resultText = await runShellCommandTool(state.session, args.command);
         } else if (server === 'shell' && tool === 'read_command') {
           resultText = await runShellReadCommandTool(state.session, args.command);
+        } else if (server === 'shell' && tool === 'profile_update') {
+          const result = await updateWorkspaceProfilePreference(state.session, args.preference);
+          resultText = JSON.stringify(result, null, 2);
         } else if (server !== 'shell') {
           await awaitRunApproval(state.session, { runId, tool: toolName });
           await awaitToolApproval(state.session, {

package/src/agent/graph.test.js

@@ -1,6 +1,9 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { createAgentGraph } from './graph.js';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildAgentSystemPrompt, createAgentGraph } from './graph.js';
 
 function sessionBase(overrides = {}) {
   return {
@@ -107,7 +110,7 @@ test('agent graph reports LLM unavailable without Donna active boilerplate', asy
   assert.doesNotMatch(result.response, /Donna is active/);
 });
 
-test('agent graph binds only the minimal read-only tool set for plain discussion, never an empty array', async () => {
+test('agent graph binds the full toolset and lets Donna decide whether to call tools', async () => {
   const seenTools = [];
   const session = sessionBase({
     llm: {
@@ -126,17 +129,17 @@ test('agent graph binds only the minimal read-only tool set for plain discussion
   const result = await agent.invoke({ input: 'salut', session });
 
   assert.equal(result.response, 'Salut, je suis là.');
-  // Never literally empty: the system prompt unconditionally describes the
-  // connected MCP tools, and sending zero tools while the prompt talks about
-  // them risks an empty/malformed completion from some models instead of a
-  // plain reply — this is what actually broke plain "salut" discussion.
   assert.ok(seenTools.length > 0);
-  assert.deepEqual(seenTools, ['shell__read_command']);
+  assert.ok(seenTools.includes('shell__read_command'));
+  assert.ok(seenTools.includes('shell__run_command'));
+  assert.ok(seenTools.includes('shell__profile_update'));
+  assert.ok(seenTools.includes('wiki__plan_set'));
+  assert.ok(seenTools.includes('wiki__plan_done'));
   assert.equal(session.headlessPlan ?? null, null);
   assert.equal(Object.keys(session.activities ?? {}).length, 0);
 });
 
-test('agent graph binds read-only tools for config questions without plan tools', async () => {
+test('agent graph does not pre-filter mutating MCP tools for config questions', async () => {
   const seenTools = [];
   const session = sessionBase({
     mcp: {
@@ -175,9 +178,82 @@ test('agent graph binds read-only tools for config questions without plan tools'
   assert.equal(result.response, 'Le profil actif est docs.');
   assert.ok(seenTools.includes('shell__read_command'));
   assert.ok(seenTools.includes('production__production_job_status'));
-  assert.equal(seenTools.includes('wiki__plan_set'), false);
-  assert.equal(seenTools.includes('production__production_start_job'), false);
-  assert.equal(seenTools.includes('shell__run_command'), false);
+  assert.ok(seenTools.includes('wiki__plan_set'));
+  assert.ok(seenTools.includes('production__production_start_job'));
+  assert.ok(seenTools.includes('shell__run_command'));
+});
+
+test('agent graph binds the full toolset for a "remember my preference" request, not just read-only tools', async () => {
+  const seenTools = [];
+  const session = sessionBase({
+    mcp: {
+      wiki: {
+        status: 'connected',
+        url: 'http://127.0.0.1:3001/mcp/',
+        tools: [
+          {
+            name: 'profile_read',
+            description: 'Read the workspace profile from .wiki/profile.md.',
+            inputSchema: { type: 'object', properties: {} },
+          },
+          {
+            name: 'profile_update',
+            description: 'Write the workspace profile to .wiki/profile.md.',
+            inputSchema: { type: 'object', properties: { content: { type: 'string' } } },
+          },
+        ],
+      },
+    },
+    llm: {
+      async completeWithTools({ tools }) {
+        seenTools.push(...tools.map((tool) => tool.function.name));
+        return {
+          content: 'Noté, je retiens cette préférence.',
+          message: { role: 'assistant', content: 'Noté, je retiens cette préférence.' },
+          tool_calls: null,
+        };
+      },
+    },
+  });
+
+  const agent = createAgentGraph();
+  const result = await agent.invoke({ input: 'retiens que je préfère des réponses courtes', session });
+
+  assert.equal(result.response, 'Noté, je retiens cette préférence.');
+  // profile_update is a write tool (doesn't match the read-only name pattern)
+  // and "retiens" doesn't appear in the config/status read-only phrasing —
+  // without action-intent coverage for remember/save/update requests, this
+  // tool would silently never be offered to the LLM at all.
+  assert.ok(seenTools.includes('wiki__profile_update'));
+  assert.ok(seenTools.includes('wiki__profile_read'));
+  assert.ok(seenTools.includes('shell__profile_update'));
+});
+
+test('buildAgentSystemPrompt includes .wiki/profile.md content so preferences apply without a tool call', () => {
+  const workspacePath = mkdtempSync(join(tmpdir(), 'donna-profile-'));
+  mkdirSync(join(workspacePath, '.wiki'), { recursive: true });
+  writeFileSync(
+    join(workspacePath, '.wiki', 'profile.md'),
+    '# Workspace Profile\n\n## User Preferences\n\n- Tutoiement : me tutoyer\n',
+  );
+  try {
+    const prompt = buildAgentSystemPrompt({
+      session: sessionBase({ workspacePath }),
+    });
+    assert.match(prompt, /Tutoiement : me tutoyer/);
+  } finally {
+    rmSync(workspacePath, { recursive: true, force: true });
+  }
+});
+
+test('buildAgentSystemPrompt omits the profile section when profile.md is missing or empty', () => {
+  const workspacePath = mkdtempSync(join(tmpdir(), 'donna-profile-empty-'));
+  try {
+    const prompt = buildAgentSystemPrompt({ session: sessionBase({ workspacePath }) });
+    assert.doesNotMatch(prompt, /Workspace profile \(\.wiki\/profile\.md\)/);
+  } finally {
+    rmSync(workspacePath, { recursive: true, force: true });
+  }
 });
 
 test('agent graph waits for tool-level approval configured on endpoint', async () => {

package/src/commands/slash.js

@@ -655,15 +655,38 @@ export function printHelp(packageJson) {
   console.log(helpText(packageJson));
 }
 
+function rawCommandAgentPrompt(command, output) {
+  return [
+    `L'utilisateur a lancé la commande shell ${command}.`,
+    'Voici la sortie brute collectée par la commande déterministe. Ne relance pas la commande et ne modifie pas les données.',
+    'Réponds à l’utilisateur à partir de ces faits, en appliquant le profil workspace et les préférences de présentation déjà chargés dans ton prompt système.',
+    '',
+    'Sortie brute:',
+    '```text',
+    output || '(empty)',
+    '```',
+  ].join('\n');
+}
+
+function rawCommandResult(command, output) {
+  return {
+    output,
+    rawOutput: true,
+    agentTrigger: rawCommandAgentPrompt(command, output),
+  };
+}
+
 export async function handleSlashCommand(line, context) {
   const args = line.slice(1).trim().split(/\s+/).filter(Boolean);
   const [command] = args;
   const step = context.onStep ?? (() => {});
-  const runAgentCommand = async (fn, verb) => {
+  const runAgentCommand = async (fn, verb, commandLabel) => {
     try {
       step(`Agents: ${verb}ing external agents…`);
       const output = await fn();
-      return { output: output || `Agents ${verb}ed.` };
+      return output
+        ? rawCommandResult(commandLabel, output)
+        : { output: `Agents ${verb}ed.` };
     } catch (err) {
       step(formatActivityError('agents', verb, err));
       return { output: err instanceof Error ? err.message : String(err) };
@@ -808,7 +831,8 @@ export async function handleSlashCommand(line, context) {
       try {
         step('Services: reading compose state…');
         await refreshMcpRuntimeStatus(context.session);
-        return { output: await listServices(context.session) };
+        const output = await listServices(context.session);
+        return rawCommandResult('/services', output);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         step(formatActivityError('services', 'list', err));
@@ -821,13 +845,13 @@ export async function handleSlashCommand(line, context) {
       // do not remap it to undefined, that bypasses any custom "all" target list and always
       // falls back to the hardcoded COMPOSE_SERVICES constant instead.
       const service = args[1];
-      if (service === 'agents') return runAgentCommand(startAgents, 'start');
+      if (service === 'agents') return runAgentCommand(startAgents, 'start', '/start agents');
       try {
         step(`Services: starting ${service ?? 'workspace services'}…`);
         const output = await startService(context.session, service);
         step('Services: refreshing MCP runtime…');
         await refreshMcpRuntimeStatus(context.session);
-        return { output };
+        return rawCommandResult(`/start${service ? ` ${service}` : ''}`, output);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         step(formatActivityError('services', 'stop', err));
@@ -836,13 +860,13 @@ export async function handleSlashCommand(line, context) {
     }
     case 'stop': {
       const service = args[1];
-      if (service === 'agents') return runAgentCommand(stopAgents, 'stop');
+      if (service === 'agents') return runAgentCommand(stopAgents, 'stop', '/stop agents');
       try {
         step(`Services: stopping ${service ?? 'workspace services'}…`);
         const output = await stopService(context.session, service);
         step('Services: refreshing MCP runtime…');
         await refreshMcpRuntimeStatus(context.session);
-        return { output };
+        return rawCommandResult(`/stop${service ? ` ${service}` : ''}`, output);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         step(formatActivityError('services', 'logs', err));
@@ -854,7 +878,8 @@ export async function handleSlashCommand(line, context) {
       const tail = args[2] ? Number(args[2]) : 120;
       try {
         step(`Services: reading logs for ${service ?? 'service'}…`);
-        return { output: await serviceLogs(context.session, service, { tail }) };
+        const output = await serviceLogs(context.session, service, { tail });
+        return rawCommandResult(`/logs ${[service, args[2]].filter(Boolean).join(' ')}`.trim(), output);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { output: message };
@@ -903,7 +928,7 @@ export async function handleSlashCommand(line, context) {
           }
           const activity = formatMcpCallActivity(serverName, toolName, output);
           if (activity) step(activity);
-          return { output };
+          return rawCommandResult(`/mcp call ${serverName} ${toolName}`, output);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           step(formatActivityError(serverName, toolName, err));
@@ -1056,7 +1081,7 @@ export async function handleSlashCommand(line, context) {
           });
           const activity = formatActivitySummary('wiki', 'index', output);
           if (activity) step(activity);
-          return { output };
+          return rawCommandResult('/wiki', output);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           step(formatActivityError('wiki', 'index', err));
@@ -1073,7 +1098,7 @@ export async function handleSlashCommand(line, context) {
           });
           const activity = formatActivitySummary('wiki', wikiArgs[0] ?? 'run', output);
           if (activity) step(activity);
-          return { output };
+          return rawCommandResult(`/wiki run ${wikiArgs.join(' ')}`, output);
         }
         return {
           output: [

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.11.6';
+const WIKI_MANAGER_VERSION = '0.11.7';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/profile.js

@@ -0,0 +1,111 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const DEFAULT_PROFILE = `# Workspace Profile
+
+## Summary
+
+No profile summary yet.
+
+## User Preferences
+
+## Working Style
+
+## Project Context
+
+## Maintenance Notes
+
+Keep this file concise. Do not store secrets, tokens, passwords, API keys, or temporary information.
+`;
+
+function profilePathForWorkspace(workspacePath) {
+  return join(workspacePath, '.wiki', 'profile.md');
+}
+
+function formatPreference(preference) {
+  const clean = String(preference ?? '').trim();
+  if (!clean) return '';
+  return clean.charAt(0).toUpperCase() + clean.slice(1);
+}
+
+function normalizeForCompare(value) {
+  return String(value ?? '')
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .trim();
+}
+
+function insertPreference(content, preference) {
+  const line = `- ${formatPreference(preference)}`;
+  const normalizedLine = normalizeForCompare(line);
+  const hasDuplicate = content
+    .split('\n')
+    .some((existing) => normalizeForCompare(existing) === normalizedLine);
+  if (hasDuplicate) {
+    return { content, changed: false, line };
+  }
+
+  const heading = '## User Preferences';
+  const index = content.indexOf(heading);
+  if (index === -1) {
+    const next = content.trimEnd();
+    return {
+      content: `${next}${next ? '\n\n' : ''}${heading}\n\n${line}\n`,
+      changed: true,
+      line,
+    };
+  }
+
+  const afterHeading = index + heading.length;
+  const nextHeading = content.slice(afterHeading).search(/\n##\s+/);
+  if (nextHeading === -1) {
+    const prefix = content.slice(0, afterHeading).trimEnd();
+    const suffix = content.slice(afterHeading).trim();
+    return {
+      content: `${prefix}\n\n${suffix ? `${suffix}\n` : ''}${line}\n`,
+      changed: true,
+      line,
+    };
+  }
+
+  const insertAt = afterHeading + nextHeading;
+  const before = content.slice(0, insertAt).trimEnd();
+  const after = content.slice(insertAt).replace(/^\n+/, '\n');
+  return {
+    content: `${before}\n${line}\n${after}`,
+    changed: true,
+    line,
+  };
+}
+
+export async function updateWorkspaceProfilePreference(session, preference) {
+  const workspacePath = session?.workspacePath;
+  if (!workspacePath) {
+    return {
+      ok: false,
+      message: 'Profil non modifié : aucun workspace chargé. Utilise /use <workspace>.',
+    };
+  }
+  const profilePath = profilePathForWorkspace(workspacePath);
+  await mkdir(join(workspacePath, '.wiki'), { recursive: true });
+  let before = DEFAULT_PROFILE;
+  try {
+    before = await readFile(profilePath, 'utf8');
+  } catch (err) {
+    if (err?.code !== 'ENOENT') throw err;
+  }
+  const inserted = insertPreference(before, preference);
+  if (inserted.changed) {
+    await writeFile(profilePath, inserted.content, 'utf8');
+  }
+  return {
+    ok: true,
+    changed: inserted.changed,
+    preference: inserted.line.replace(/^- /, ''),
+    message: inserted.changed
+      ? `Profil mis à jour : ${inserted.line.replace(/^- /, '')}`
+      : `Profil déjà à jour : ${inserted.line.replace(/^- /, '')}`,
+  };
+}

package/src/core/skills.js

@@ -46,7 +46,7 @@ function readSkillFile(filePath, fallbackName, scope) {
   };
 }
 
-function readOptionalText(filePath) {
+export function readOptionalText(filePath) {
   if (!existsSync(filePath)) return '';
   return readFileSync(filePath, 'utf8').trim();
 }

package/src/shell/StartupScreen.tsx

@@ -14,6 +14,15 @@ type StartupItem = {
   detail: string;
 };
 
+const DONNA_LOGO = `
+██████╗  ██████╗ ███╗   ██╗███╗   ██╗ █████╗
+██╔══██╗██╔═══██╗████╗  ██║████╗  ██║██╔══██╗
+██║  ██║██║   ██║██╔██╗ ██║██╔██╗ ██║███████║
+██║  ██║██║   ██║██║╚██╗██║██║╚██╗██║██╔══██║
+██████╔╝╚██████╔╝██║ ╚████║██║ ╚████║██║  ██║
+╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═══╝╚═╝  ╚═╝
+`.trim();
+
 function statusDot(ready: boolean) {
   return ready ? '●' : '○';
 }
@@ -92,8 +101,8 @@ export function StartupScreen(props: {
   const [mode, setMode] = createSignal<'home' | 'workspace-select'>('home');
   const [selected, setSelected] = createSignal(0);
   let lastKeyboardEventId = 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)));
+  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)));
 
@@ -251,10 +260,16 @@ export function StartupScreen(props: {
         </box>
         <text height={1} fg="#7F8C8D" content={fit(subtitle(), innerWidth())} />
         <text height={1}>{''}</text>
-        <box height={4} flexDirection="column" border={['left']} borderStyle="heavy" borderColor="#8BD5CA" paddingX={1}>
-          <text height={1} fg="#EAF2F8" content={fit('DONNA', innerWidth() - 2)} />
-          <text height={1} fg="#8BD5CA" content={fit('Living knowledge for AI agents', innerWidth() - 2)} />
-          <text height={1} fg="#7F8C8D" content={fit('Local workspaces · MCP agents · traceable runs', innerWidth() - 2)} />
+        <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()} />

package/src/shell/repl.js

@@ -961,22 +961,22 @@ function renderScreen({ packageJson, session, messages, inputBuffer, busy = fals
   output.write(buf);
 }
 
-async function runAgentTurn(input, { agent, session, onUpdate, onStep }) {
+async function runAgentTurn(input, { agent, session, onUpdate, onStep, displayInput = input }) {
   const messages = conversationMessages(session);
   const history = toConversationHistory(messages);
   session._onStep = onStep ?? null;
   session.packageJson = session.packageJson ?? {};
   dispatchAgentEvent(session, createAgentEvent('run_started', {
     origin: 'user',
-    payload: { input },
+    payload: { input: displayInput },
   }));
   dispatchAgentEvent(session, createAgentEvent('user_message', {
     origin: 'user',
-    payload: { content: input },
+    payload: { content: displayInput },
   }));
 
   // Show the user's input in the conversation (mirrors runDirectChatTurn).
-  messages.push({ role: 'user', content: input });
+  messages.push({ role: 'user', content: displayInput });
   onUpdate?.();
 
   // Create the donna bubble immediately so "Thinking…" is visible during TTFT.
@@ -1182,6 +1182,7 @@ export async function runLine(line, { agent, packageJson, session, onUpdate, onS
     onStep?.(`Shell: ${trimmed}`);
     const result = await handleSlashCommand(trimmed, { packageJson, session, onStep });
     const messages = conversationMessages(session);
+    const handoffRawToAgent = Boolean(result.rawOutput && result.agentTrigger && agent);
     if (result.output) {
       const parts = trimmed.split(/\s+/);
       if (parts[0] === '/mcp' && parts[1] === 'call' && parts[2]) {
@@ -1196,10 +1197,15 @@ export async function runLine(line, { agent, packageJson, session, onUpdate, onS
           rememberProductionActivity(session, payload);
         }
       }
+    }
+    if (result.output && !handoffRawToAgent) {
       messages.push({ role: 'command', content: result.output });
       onUpdate?.();
     }
-    if (result.agentTrigger && agent) {
+    if (handoffRawToAgent) {
+      const agentResult = await runAgentTurn(result.agentTrigger, { agent, session, onUpdate, onStep, displayInput: trimmed });
+      if (agentResult.aborted) return { exit: false, aborted: true };
+    } else if (result.agentTrigger && agent) {
       const agentResult = await runAgentTurn(result.agentTrigger, { agent, session, onUpdate, onStep });
       if (agentResult.aborted) return { exit: false, aborted: true };
     }
@@ -1572,33 +1578,35 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
             conversationMessages(session).push({ role: 'command', content: `Approval ${result.approved ? 'accepted' : 'not found'}: ${id}` });
             syncRuntimeState();
           }
-        } else if (runtime?.url && !session.chatMode && !line.trim().startsWith('/')) {
-          conversationMessages(session).push({ role: 'user', content: line });
-          const outcome = await submitRuntimeRun(line, { runtime, session });
-          if (outcome.kind === 'accepted') {
-            activityLines = [...activityLines, 'runtime: run accepted'].slice(-LOWER_DETAIL_ROWS);
-          } else if (outcome.kind === 'queued') {
-            conversationMessages(session).push({ role: 'command', content: 'Runtime is busy — request added to the control queue, it will start automatically.' });
-            activityLines = [...activityLines, 'runtime: control queued'].slice(-LOWER_DETAIL_ROWS);
-          } else if (outcome.kind === 'observe' || outcome.kind === 'converse' || outcome.kind === 'mutate') {
-            const explanation = outcome.result?.explanation ?? 'Runtime control message accepted.';
-            conversationMessages(session).push({ role: 'command', content: explanation });
-            activityLines = [...activityLines, `runtime: ${outcome.kind}`].slice(-LOWER_DETAIL_ROWS);
-          } else if (outcome.kind === 'ambiguous') {
-            conversationMessages(session).push({ role: 'command', content: 'Runtime could not classify that message. Use /queue for a future run, or ask/status more explicitly.' });
-            activityLines = [...activityLines, 'runtime: ambiguous control'].slice(-LOWER_DETAIL_ROWS);
+        } else {
+          if (runtime?.url && !session.chatMode && !line.trim().startsWith('/')) {
+            conversationMessages(session).push({ role: 'user', content: line });
+            const outcome = await submitRuntimeRun(line, { runtime, session });
+            if (outcome.kind === 'accepted') {
+              activityLines = [...activityLines, 'runtime: run accepted'].slice(-LOWER_DETAIL_ROWS);
+            } else if (outcome.kind === 'queued') {
+              conversationMessages(session).push({ role: 'command', content: 'Runtime is busy — request added to the control queue, it will start automatically.' });
+              activityLines = [...activityLines, 'runtime: control queued'].slice(-LOWER_DETAIL_ROWS);
+            } else if (outcome.kind === 'observe' || outcome.kind === 'converse' || outcome.kind === 'mutate') {
+              const explanation = outcome.result?.explanation ?? 'Runtime control message accepted.';
+              conversationMessages(session).push({ role: 'command', content: explanation });
+              activityLines = [...activityLines, `runtime: ${outcome.kind}`].slice(-LOWER_DETAIL_ROWS);
+            } else if (outcome.kind === 'ambiguous') {
+              conversationMessages(session).push({ role: 'command', content: 'Runtime could not classify that message. Use /queue for a future run, or ask/status more explicitly.' });
+              activityLines = [...activityLines, 'runtime: ambiguous control'].slice(-LOWER_DETAIL_ROWS);
+            } else {
+              conversationMessages(session).push({ role: 'command', content: `Runtime error: ${outcome.message}` });
+              activityLines = [...activityLines, `runtime error: ${outcome.message}`].slice(-LOWER_DETAIL_ROWS);
+            }
+            syncRuntimeState();
+          } else if (!session.chatMode && !line.trim().startsWith('/')) {
+            const message = recordRuntimeUnavailableAgentInput(session, line, runtime);
+            activityLines = [...activityLines, message ?? 'runtime: disconnected'].slice(-LOWER_DETAIL_ROWS);
           } else {
-            conversationMessages(session).push({ role: 'command', content: `Runtime error: ${outcome.message}` });
-            activityLines = [...activityLines, `runtime error: ${outcome.message}`].slice(-LOWER_DETAIL_ROWS);
+            const result = await runLine(line, { agent, packageJson, session, onUpdate: rerender, onStep });
+            done = result.exit;
+            aborted = result.aborted ?? false;
           }
-          syncRuntimeState();
-        } else if (!session.chatMode && !line.trim().startsWith('/')) {
-          const message = recordRuntimeUnavailableAgentInput(session, line, runtime);
-          activityLines = [...activityLines, message ?? 'runtime: disconnected'].slice(-LOWER_DETAIL_ROWS);
-        } else {
-          const result = await runLine(line, { agent, packageJson, session, onUpdate: rerender, onStep });
-          done = result.exit;
-          aborted = result.aborted ?? false;
         }
       } catch (err) {
         if (err.name !== 'AbortError') throw err;

package/src/shell/repl.test.js

@@ -1,10 +1,14 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import {
   applyRuntimeStateToShellSession,
   createSession,
   conversationMessages,
   recordRuntimeUnavailableAgentInput,
+  runLine,
   runtimeStatusLine,
   runtimeUnavailableAgentMessage,
   submitRuntimeRun,
@@ -121,6 +125,28 @@ test('submitRuntimeRun reports a non-409 error without throwing or calling /cont
   }
 });
 
+test('runLine does not update workspace profile before Donna handles the request', async () => {
+  const workspacePath = mkdtempSync(join(tmpdir(), 'donna-profile-shell-'));
+  mkdirSync(join(workspacePath, '.wiki'), { recursive: true });
+  try {
+    const session = createSession();
+    session.workspace = 'docs';
+    session.workspacePath = workspacePath;
+    const result = await runLine('ajoute a mon profil que les statuts Docker sont rendus en tableau', {
+      agent: null,
+      packageJson: { version: 'test' },
+      session,
+      chatMode: true,
+    });
+
+    assert.equal(result.exit, false);
+    assert.equal(existsSync(join(workspacePath, '.wiki', 'profile.md')), false);
+    assert.notDeepEqual(conversationMessages(session).map((message) => message.role), ['user', 'donna']);
+  } finally {
+    rmSync(workspacePath, { recursive: true, force: true });
+  }
+});
+
 test('agent mode without runtime records a visible error instead of falling back locally', () => {
   const session = createSession();
   session.chatMode = false;