@dotdrelle/wiki-manager 0.15.26 → 0.15.28

package/src/runtime/client.js

@@ -150,6 +150,24 @@ export async function postRuntimeCancel({
   return response.json();
 }
 
+// Redo support: keeps the conversation entry at `index` and drops everything
+// the runtime recorded after it. Returns the server's payload so a caller can
+// distinguish "nothing to truncate" from "a run is still active".
+export async function postRuntimeConversationTruncate(index, {
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+  workspace = null,
+} = {}) {
+  const response = await fetch(runtimeEndpoint(url, '/conversation/truncate', workspace), {
+    method: 'POST',
+    headers: { ...runtimeHeaders(token), 'content-type': 'application/json' },
+    body: JSON.stringify({ index, ...(workspace ? { workspace } : {}) }),
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) return { truncated: false, reason: payload?.reason ?? `http_${response.status}` };
+  return payload;
+}
+
 export async function postRuntimeKill({
   url = runtimeUrlFromEnv(),
   token = runtimeToken(),

package/src/runtime/lifecycle.js

@@ -55,7 +55,11 @@ export async function assertRuntimeNode(executable = runtimeNodeExecutable()) {
 }
 
 export async function ensureRuntime({
-  host = process.env.WIKI_MANAGER_RUNTIME_HOST ?? '127.0.0.1',
+  // 0.0.0.0, like `wiki-workspace runtime up` has always used: the shell's
+  // autostarted runtime used to bind 127.0.0.1, so `serve` in Docker got
+  // ECONNREFUSED on host.docker.internal and the workspace UI reported no
+  // runtime. Exposing the port always generates an auth token.
+  host = process.env.WIKI_MANAGER_RUNTIME_HOST ?? '0.0.0.0',
   port = Number(process.env.WIKI_MANAGER_RUNTIME_PORT ?? 7788),
   stateDir = process.env.WIKI_MANAGER_STATE_DIR ?? defaultRuntimeStateDir(),
   url = process.env.WIKI_MANAGER_RUNTIME_URL ?? `http://127.0.0.1:${port}`,

package/src/runtime/server.js

@@ -1,6 +1,6 @@
 import { createServer } from 'node:http';
 import { randomUUID, timingSafeEqual } from 'node:crypto';
-import { createAgentEvent, dispatchAgentEvent, resetSessionProjection, reduceAgentEvents } from '../core/agentEvents.js';
+import { conversationEventSequences, createAgentEvent, dispatchAgentEvent, resetSessionProjection, reduceAgentEvents } from '../core/agentEvents.js';
 import { activeCacertPath } from '../core/cacert.js';
 import { normalizePlanPatch, rebasePlanPatch } from '../core/planPatch.js';
 import { validateContractInDev } from '../contracts/schemas.js';
@@ -420,6 +420,48 @@ export function startRuntimeServer({
         });
         return;
       }
+      // Redo: keep the conversation entry at `index` (the question) and drop
+      // everything the runtime recorded after it. The conversation is derived
+      // from the event log, so a UI-side deletion alone would be undone by the
+      // next /state merge — the truncation has to happen here.
+      if (request.method === 'POST' && url.pathname === '/conversation/truncate') {
+        const { body, workspace, context } = await resolveBodyContext(request, url);
+        if (context?.running) {
+          // Truncating under a live run would delete events it is still
+          // appending to. The caller cancels first.
+          sendJson(response, 409, { truncated: false, reason: 'run_active' });
+          return;
+        }
+        const resolvedWorkspace = context?.workspace ?? workspace ?? null;
+        if (!resolvedWorkspace) {
+          // Unscoped, redo would truncate every workspace's event history —
+          // never allow the global/no-workspace conversation to reach it.
+          sendJson(response, 400, { truncated: false, reason: 'workspace_required' });
+          return;
+        }
+        const index = Number(body.index);
+        if (!Number.isInteger(index) || index < 0) {
+          sendJson(response, 400, { truncated: false, reason: 'invalid_index' });
+          return;
+        }
+        const events = store.listEvents({ workspace: resolvedWorkspace });
+        const sequences = conversationEventSequences(events);
+        const boundary = sequences[index];
+        if (!Number.isFinite(boundary)) {
+          sendJson(response, 400, { truncated: false, reason: 'index_out_of_range' });
+          return;
+        }
+        const removedEvents = store.deleteEventsAfter(boundary, { workspace: resolvedWorkspace });
+        // getState prefers the in-memory projection over the event log, so the
+        // deleted answers would survive in RAM without this rehydration.
+        if (context?.session) {
+          resetSessionProjection(context.session);
+          store.hydrateSession(context.session, { workspace: resolvedWorkspace });
+        }
+        publishState(resolvedWorkspace, context);
+        sendJson(response, 200, { truncated: true, index, removedEvents });
+        return;
+      }
       if (request.method === 'POST' && url.pathname === '/resume') {
         const workspace = workspaceFromUrl(url);
         const result = await resume?.({ workspace });

package/src/runtime/server.test.js

@@ -1614,3 +1614,120 @@ test('runtime health reports active runs across workspaces', async (t) => {
     await handle.close();
   }
 });
+
+test('redo truncation drops the aftermath of one question and refuses during a run', async (t) => {
+  const events = [
+    { ...createAgentEvent('user_message', { origin: 'user', payload: { content: 'question' } }), sequence: 1 },
+    { ...createAgentEvent('assistant_message', { origin: 'runtime', payload: { content: 'answer' } }), sequence: 2 },
+  ];
+  let deleted = null;
+  let hydrated = false;
+  let running = true;
+  const store = {
+    dbPath: ':memory:',
+    getState: () => ({ status: 'idle' }),
+    listEvents: () => events,
+    deleteEventsAfter: (sequence, options) => { deleted = { sequence, ...options }; return 1; },
+    hydrateSession: () => { hydrated = true; },
+  };
+
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store,
+      session: {},
+      getContext: async () => ({ workspace: 'demo', session: {}, running }),
+      run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const url = `http://127.0.0.1:${handle.port}/conversation/truncate`;
+    const post = (body) => fetch(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+
+    // Truncating under a live run would delete events it is still appending.
+    const active = await post({ index: 0 });
+    assert.equal(active.status, 409);
+    assert.equal((await active.json()).reason, 'run_active');
+    assert.equal(deleted, null);
+
+    running = false;
+    const outOfRange = await post({ index: 9 });
+    assert.equal(outOfRange.status, 400);
+    assert.equal((await outOfRange.json()).reason, 'index_out_of_range');
+
+    const invalid = await post({ index: -1 });
+    assert.equal(invalid.status, 400);
+    assert.equal((await invalid.json()).reason, 'invalid_index');
+
+    const ok = await post({ index: 0 });
+    assert.equal(ok.status, 200);
+    assert.deepEqual(await ok.json(), { truncated: true, index: 0, removedEvents: 1 });
+    // Keeps the question (sequence 1) and drops everything recorded after it.
+    assert.deepEqual(deleted, { sequence: 1, workspace: 'demo' });
+    // getState prefers the in-memory projection, so the deleted answers would
+    // survive in RAM without this rehydration.
+    assert.equal(hydrated, true);
+  } finally {
+    await handle.close();
+  }
+});
+
+test('redo truncation refuses when no workspace can be resolved', async (t) => {
+  // The global/no-workspace conversation is a real reachable mode (chatting
+  // before /use <workspace>). Without this guard the handler would fall
+  // through to an unscoped store.deleteEventsAfter, wiping every workspace's
+  // event history for one redo click.
+  let deleted = null;
+  const store = {
+    dbPath: ':memory:',
+    getState: () => ({ status: 'idle' }),
+    listEvents: () => [],
+    deleteEventsAfter: (sequence, options) => { deleted = { sequence, ...options }; return 1; },
+    hydrateSession: () => {},
+  };
+
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store,
+      session: {},
+      getContext: async () => ({ workspace: null, session: {}, running: false }),
+      run: async () => {},
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const url = `http://127.0.0.1:${handle.port}/conversation/truncate`;
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ index: 0 }),
+    });
+    assert.equal(response.status, 400);
+    assert.equal((await response.json()).reason, 'workspace_required');
+    assert.equal(deleted, null);
+  } finally {
+    await handle.close();
+  }
+});

package/src/runtime/store.js

@@ -676,6 +676,52 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     return tasks.length;
   }
 
+  // Drops every event strictly after `sequence`, i.e. everything that happened
+  // after one conversation entry. Backs the redo action: the question stays,
+  // the answers, plan steps, activities and logs it produced are removed.
+  // Scoped to the workspace so a redo in one workspace never touches another —
+  // requires a real workspace; callers must resolve one before calling this,
+  // an unscoped call would otherwise touch every workspace's history.
+  // Destructive: these events also feed listAuditTrail, so a redo erases that
+  // stretch of audit history too. Runs entirely produced by the deleted range
+  // (no event at/before the boundary) are removed as well, cascading their
+  // task_groups/tasks/task_dependencies/plan_revisions via ON DELETE CASCADE;
+  // the non-cascading side tables (task_assignments/task_attempts/
+  // task_results/approval_grants) are cleared explicitly, same as
+  // clearWorkspaceState below.
+  function deleteEventsAfter(sequence, { workspace = null } = {}) {
+    const boundary = Number(sequence);
+    if (!Number.isFinite(boundary) || !workspace) return 0;
+    const orphanedRunIds = db.prepare(`
+      SELECT DISTINCT run_id FROM events
+      WHERE sequence > ? AND workspace = ? AND run_id IS NOT NULL
+        AND run_id NOT IN (
+          SELECT run_id FROM events WHERE sequence <= ? AND workspace = ? AND run_id IS NOT NULL
+        )
+    `).all(boundary, workspace, boundary, workspace).map((row) => row.run_id);
+    db.exec('BEGIN');
+    try {
+      const delResults = db.prepare('DELETE FROM task_results WHERE task_id IN (SELECT id FROM tasks WHERE run_id = ?)');
+      const delAssignments = db.prepare('DELETE FROM task_assignments WHERE task_id IN (SELECT id FROM tasks WHERE run_id = ?)');
+      const delAttempts = db.prepare('DELETE FROM task_attempts WHERE run_id = ?');
+      const delApprovals = db.prepare('DELETE FROM approval_grants WHERE run_id = ?');
+      const delRun = db.prepare('DELETE FROM runs WHERE id = ?');
+      for (const runId of orphanedRunIds) {
+        delResults.run(runId);
+        delAssignments.run(runId);
+        delAttempts.run(runId);
+        delApprovals.run(runId);
+        delRun.run(runId);
+      }
+      const changes = db.prepare('DELETE FROM events WHERE sequence > ? AND workspace = ?').run(boundary, workspace).changes ?? 0;
+      db.exec('COMMIT');
+      return changes;
+    } catch (error) {
+      db.exec('ROLLBACK');
+      throw error;
+    }
+  }
+
   // Full wipe of a workspace's persisted runtime state: runs (and, via the
   // ON DELETE CASCADE foreign keys, their task_groups/tasks/task_dependencies/
   // plan_revisions/approval_grants), the event log, and the queue. The
@@ -1241,6 +1287,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     interruptRuns,
     cancelActiveTasksForInterruptedRuns,
     clearWorkspaceState,
+    deleteEventsAfter,
     saveQueue,
     listQueue,
     listTasks,

package/src/runtime/store.test.js

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import test from 'node:test';
-import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { conversationEventSequences, createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { openRuntimeStore } from './store.js';
 
 function runtimeStateDir() {
@@ -1018,3 +1018,91 @@ test('runtime store identifies recoverable workspaces and interrupts stale runs'
   assert.equal(store.listRuns({ workspace: 'acme' })[0].status, 'interrupted');
   store.close();
 });
+
+test('deleteEventsAfter removes one question\'s aftermath and nothing else', () => {
+  const stateDir = runtimeStateDir();
+  const store = openRuntimeStore({ stateDir });
+  const persist = (type, payload, workspace) => store.persistEvent({
+    ...createAgentEvent(type, { origin: 'runtime', payload }),
+    workspace,
+  });
+
+  persist('user_message', { content: 'first question' }, 'docs');
+  persist('assistant_message', { content: 'first answer' }, 'docs');
+  persist('user_message', { content: 'second question' }, 'docs');
+  persist('assistant_message', { content: 'second answer' }, 'docs');
+  // A redo in one workspace must never touch another's history.
+  persist('user_message', { content: 'other workspace' }, 'acme');
+
+  const events = store.listEvents({ workspace: 'docs' });
+  const sequences = conversationEventSequences(events);
+  // Keep "second question" (index 2), drop everything recorded after it.
+  const removed = store.deleteEventsAfter(sequences[2], { workspace: 'docs' });
+
+  assert.equal(removed, 1);
+  assert.deepEqual(
+    store.getProjection({ workspace: 'docs' }).conversation.map((message) => message.content),
+    ['first question', 'first answer', 'second question'],
+  );
+  assert.equal(store.listEvents({ workspace: 'acme' }).length, 1);
+  // A boundary that does not exist is a no-op rather than a silent wipe.
+  assert.equal(store.deleteEventsAfter(undefined, { workspace: 'docs' }), 0);
+  assert.equal(store.listEvents({ workspace: 'docs' }).length, 3);
+  store.close();
+});
+
+test('deleteEventsAfter without a workspace is a no-op, never an unscoped wipe', () => {
+  const stateDir = runtimeStateDir();
+  const store = openRuntimeStore({ stateDir });
+  store.persistEvent(createAgentEvent('user_message', { origin: 'user', workspace: 'docs', payload: { content: 'q' } }));
+  store.persistEvent(createAgentEvent('user_message', { origin: 'user', workspace: 'acme', payload: { content: 'q' } }));
+
+  assert.equal(store.deleteEventsAfter(0, { workspace: null }), 0);
+  assert.equal(store.deleteEventsAfter(0, {}), 0);
+  assert.equal(store.listEvents({ workspace: 'docs' }).length, 1);
+  assert.equal(store.listEvents({ workspace: 'acme' }).length, 1);
+  store.close();
+});
+
+test('deleteEventsAfter removes bookkeeping only for runs entirely produced by the deleted range', () => {
+  const stateDir = runtimeStateDir();
+  const store = openRuntimeStore({ stateDir });
+  const taskEvents = (runId, taskId) => [
+    createAgentEvent('run_started', {
+      origin: 'runtime', runId, workspace: 'docs', payload: { input: 'build docs', workspace: 'docs' },
+    }),
+    createAgentEvent('task.created', {
+      origin: 'plan_integrator', runId, taskId, workspace: 'docs', payload: { runId, task: plannedTask(taskId) },
+    }),
+    createAgentEvent('task.assigned', {
+      origin: 'assignment_manager', runId, taskId, workspace: 'docs',
+      payload: { runId, taskId, attemptId: `${taskId}:attempt-1`, assignment: {
+        attemptId: `${taskId}:attempt-1`, agentInstanceId: 'production-main', agentId: 'production', poolId: 'production-pool',
+      } },
+    }),
+    createAgentEvent('task.started', {
+      origin: 'dispatcher', runId, taskId, workspace: 'docs',
+      payload: { runId, taskId, attemptId: `${taskId}:attempt-1`, jobId: 'job-1', startedAt: '2026-07-07T10:00:00.000Z' },
+    }),
+  ];
+
+  // A run that completed before the redo boundary must survive untouched.
+  for (const event of taskEvents('run-before', 'run-before:build-a')) store.persistEvent(event);
+  const boundarySequence = store.listEvents({ workspace: 'docs' }).at(-1).sequence;
+  // A run triggered by the redone question — entirely after the boundary — is
+  // what redo is dropping, so its bookkeeping should go with it.
+  for (const event of taskEvents('run-after', 'run-after:build-a')) store.persistEvent(event);
+
+  assert.equal(store.db.prepare('SELECT COUNT(*) AS n FROM runs').get().n, 2);
+  assert.equal(store.db.prepare('SELECT COUNT(*) AS n FROM task_assignments').get().n, 2);
+  assert.equal(store.db.prepare('SELECT COUNT(*) AS n FROM task_attempts').get().n, 2);
+
+  store.deleteEventsAfter(boundarySequence, { workspace: 'docs' });
+
+  assert.deepEqual(store.listRuns({ workspace: 'docs' }).map((run) => run.id), ['run-before']);
+  assert.deepEqual(store.listTasks({ runId: 'run-before' }).map((task) => task.id), ['run-before:build-a']);
+  assert.equal(store.listTasks({ runId: 'run-after' }).length, 0);
+  assert.equal(store.db.prepare('SELECT COUNT(*) AS n FROM task_assignments').get().n, 1);
+  assert.equal(store.db.prepare('SELECT COUNT(*) AS n FROM task_attempts').get().n, 1);
+  store.close();
+});

package/src/shell/LeftPane.tsx

@@ -1,9 +1,10 @@
 /** @jsxImportSource @opentui/solid */
-import { For, createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
+import { For, Show, createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
 import { StyledText, bg as styledBg, fg as styledFg, link as styledLink } from '@opentui/core';
-import { execFile } from 'node:child_process';
+import { useRenderer } from '@opentui/solid';
 import { colorForRenderedLine, helpCommandParts, keyValueParts, renderPlainMarkdown } from './renderer';
 import { httpLinkParts, wrapHttpLinks } from './externalLinks.js';
+import { normalizeExternalUrl } from './openExternal.js';
 
 const LEGACY_DONNA_ROLE = 'do' + 't';
 
@@ -62,17 +63,11 @@ function styledSegments(segments: Segment[]) {
   }));
 }
 
-function openSingleLineLink(segments: Segment[]) {
+// A row carries a link only when it points at exactly one target; two links on
+// the same line would make a click ambiguous.
+function singleLineUrl(segments: Segment[]) {
   const urls = [...new Set(segments.map((segment) => segment.url).filter(Boolean))] as string[];
-  if (urls.length !== 1) return;
-  try {
-    const parsed = new URL(urls[0]);
-    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return;
-    const opener = process.platform === 'darwin' ? 'open' : 'xdg-open';
-    execFile(opener, [parsed.toString()], () => {});
-  } catch {
-    // Invalid URLs remain copyable text and never reach the system opener.
-  }
+  return urls.length === 1 ? normalizeExternalUrl(urls[0]) : null;
 }
 type RenderedLine = {
   segments: Segment[];
@@ -82,6 +77,8 @@ type RenderedLine = {
   statusLeft?: string;
   statusRight?: string;
   copyContent?: string;
+  redoContent?: string;
+  redoIndex?: number;
 };
 const STATUS_COLUMN_GAP = 2;
 type HelpCard = { title: string; text: string; example: string };
@@ -145,11 +142,15 @@ function WelcomeHelpPanels(props: { width: number }) {
 }
 
 const COPY_BTN = ' [ copy ]';
+// Only user messages carry it: redo re-asks *this* question, so the action has
+// to sit on the message it acts upon.
+const REDO_BTN = ' [ redo ]';
 
-function messageHeaderSegments(role: string, columns: number): Segment[] {
+function messageHeaderSegments(role: string, columns: number, withRedo = false): Segment[] {
   const label = `[${roleLabel(role)}]`;
   const left = '── ';
-  const rightLength = Math.max(2, columns - left.length - label.length - 1 - COPY_BTN.length);
+  const actionsLength = COPY_BTN.length + (withRedo ? REDO_BTN.length : 0);
+  const rightLength = Math.max(2, columns - left.length - label.length - 1 - actionsLength);
   return [
     { text: left, color: '#4B5563' },
     { text: label, color: roleColor(role) },
@@ -415,9 +416,14 @@ function conversationLines(messages: Array<{ role: string; content: string }>, c
     const raw = String(message.content || '');
     const previous = index > 0 ? messages[index - 1] : null;
     const showHeader = !previous || headerGroupKey(previous.role) !== headerGroupKey(message.role);
+    const canRedo = message.role === 'user' && raw.trim().length > 0;
     const headerLines: RenderedLine[] = showHeader
       ? [
-          { segments: messageHeaderSegments(message.role, columns), copyContent: raw },
+          {
+            segments: messageHeaderSegments(message.role, columns, canRedo),
+            copyContent: raw,
+            ...(canRedo ? { redoContent: raw, redoIndex: index } : {}),
+          },
           { segments: [{ text: ' ', color: '#D6DEE8' }] },
         ]
       : [];
@@ -466,7 +472,15 @@ export function ConversationView(props: {
   onScroll: (delta: number) => void;
   spinnerFrame: string;
   onCopy?: (content: string) => void;
+  onRedo?: (index: number, content: string) => void;
+  onOpenLink?: (url: string) => void;
 }) {
+  const renderer = useRenderer();
+  // Terminals have no CSS cursor, but OpenTUI can ask the emulator to swap the
+  // mouse pointer shape. Without it nothing on screen distinguishes a clickable
+  // link from ordinary blue text, so operators never discovered links were
+  // clickable at all.
+  const hoverLink = (url: string | null) => renderer?.setMousePointer?.(url ? 'pointer' : 'default');
   const allLines = createMemo(() => conversationLines(props.messages, props.columns));
   const visibleLines = () => {
     const lines = allLines();
@@ -511,6 +525,13 @@ export function ConversationView(props: {
                 {(seg: Segment) => <text width={seg.width} fg={seg.color} bg={seg.bg}>{seg.text}</text>}
               </For>
               <text fg="#4B5563" content={COPY_BTN} onMouseUp={() => props.onCopy?.(line.copyContent!)} />
+              <Show when={line.redoContent !== undefined}>
+                <text
+                  fg="#FBBF24"
+                  content={REDO_BTN}
+                  onMouseUp={() => props.onRedo?.(line.redoIndex!, line.redoContent!)}
+                />
+              </Show>
             </box>
           ) : line.role === 'user' && line.userBubbleWidth ? (
             <box height={1} flexDirection="row" overflow="hidden">
@@ -567,7 +588,12 @@ export function ConversationView(props: {
               height={1}
               flexDirection="row"
               overflow="hidden"
-              onMouseUp={() => openSingleLineLink(line.segments)}
+              onMouseOver={() => hoverLink(singleLineUrl(line.segments))}
+              onMouseOut={() => hoverLink(null)}
+              onMouseUp={() => {
+                const url = singleLineUrl(line.segments);
+                if (url) props.onOpenLink?.(url);
+              }}
             >
               <text>{styledSegments(line.segments)}</text>
             </box>
@@ -748,6 +774,8 @@ export function LeftPane(props: {
   spinnerFrame: string;
   onInputHeightChange: (height: number) => void;
   onCopy?: (content: string) => void;
+  onRedo?: (index: number, content: string) => void;
+  onOpenLink?: (url: string) => void;
 }) {
   const modeColor = () => props.chatMode ? '#22C55E' : '#06B6D4';
   const modeLabel = () => props.chatMode ? 'CHAT MODE  direct LLM, no tools' : 'AGENTIC MODE  LangGraph + MCP tools';
@@ -777,6 +805,8 @@ export function LeftPane(props: {
           onScroll={props.scrollConversation}
           spinnerFrame={props.spinnerFrame}
           onCopy={props.onCopy}
+          onRedo={props.onRedo}
+          onOpenLink={props.onOpenLink}
         />
       )}
       <ChatInput

package/src/shell/RightPane.tsx

@@ -458,8 +458,7 @@ export function QueuePanel(props: { items: QueueItem[]; info: QueueInfo; width:
   );
 }
 
-function TabHeader(props: { active: 'plan' | 'queue'; queueCount: number; width: number; onTabClick: (tab: 'plan' | 'queue') => void }) {
-  const lineWidth = () => Math.max(8, props.width - 2);
+function TabHeader(props: { active: 'plan' | 'queue'; queueCount: number; onTabClick: (tab: 'plan' | 'queue') => void }) {
   const planActive = () => props.active === 'plan';
   return (
     <box height={1} flexDirection="row" paddingX={1}>
@@ -476,7 +475,6 @@ function TabHeader(props: { active: 'plan' | 'queue'; queueCount: number; width:
         content={` Queue (${props.queueCount}) `}
         onMouseUp={() => props.onTabClick('queue')}
       />
-      <text fg="#7F8C8D" content={fit('  Ctrl+Q', Math.max(0, lineWidth() - 24))} />
     </box>
   );
 }
@@ -510,7 +508,7 @@ export function RightPane(props: {
       overflow="hidden"
       focusable={false}
     >
-      <TabHeader active={props.activeTab} queueCount={props.queueInfo.active} width={props.width} onTabClick={props.onTabClick} />
+      <TabHeader active={props.activeTab} queueCount={props.queueInfo.active} onTabClick={props.onTabClick} />
       <Show when={props.pendingApprovals.length > 0}>
         <box height={2} flexDirection="column" border={['left']} borderStyle="heavy" borderColor="#FBBF24" paddingX={1}>
           <text fg="#FBBF24" content={`${props.pendingApprovals.length} approbation(s) requise(s)`} />

package/src/shell/SetupWizard.tsx

@@ -29,7 +29,18 @@ type Step =
 type LogEntry = { icon: string; label: string; detail?: string };
 
 const PROVIDERS = ['OpenAI', 'Anthropic', 'Ollama (local)', 'Other (OpenAI-compatible)'];
-const PLACEHOLDER_MODEL_RE = /YOUR_|<your/i;
+// The scaffolded .wikirc.yaml ships fake endpoints and secrets so the file
+// documents its own shape (`https://mon-provider.example.com/v1`,
+// `http://infinity.local:7997/v1`, `YOUR_LLM_API_KEY`…). Preloading them into
+// the wizard turned every field into a plausible-looking answer the operator
+// had to notice and delete — and a skipped step silently wrote the fake value
+// to the real config. Treat them as "not configured" instead.
+const PLACEHOLDER_VALUE_RE = /YOUR_|<your|example\.com|infinity\.local/i;
+
+function configuredValue(value: unknown) {
+  const text = typeof value === 'string' ? value.trim() : '';
+  return text && !PLACEHOLDER_VALUE_RE.test(text) ? text : null;
+}
 const MAIN_MENU = ['Agents', 'Workspaces', 'LLM configuration', 'Vector search', '---', 'Close'];
 
 function defaultBaseUrl(provider: string) {
@@ -317,19 +328,20 @@ export function SetupWizard(props: {
       const { config } = loadWikircProfile(workspacePath, context?.profileName ?? 'default');
       if (config?.language) setLanguage(String(config.language));
       if (config?.llm?.provider) {
-        const model = config.llm.model;
         setLlm({
           provider: normalizeProvider(config.llm.provider),
-          baseUrl: config.llm.baseUrl,
-          apiKey: config.llm.apiKey,
-          model: (model && !PLACEHOLDER_MODEL_RE.test(model)) ? model : null,
+          baseUrl: configuredValue(config.llm.baseUrl),
+          apiKey: configuredValue(config.llm.apiKey),
+          model: configuredValue(config.llm.model),
         });
       }
       if (config?.retrieval?.vector) {
         setVector({
           provider: config.retrieval.vector.provider,
-          baseUrl: config.retrieval.vector.baseUrl,
-          apiKey: config.retrieval.vector.apiKey,
+          // Null here is what makes the embeddings step fall back to the base
+          // URL the operator just entered, instead of the scaffold's fake one.
+          baseUrl: configuredValue(config.retrieval.vector.baseUrl),
+          apiKey: configuredValue(config.retrieval.vector.apiKey),
           embeddingModel: config.retrieval.vector.embeddingModel,
           rerankEnabled: config.retrieval.vector.rerankEnabled,
           rerankerModel: config.retrieval.vector.rerankerModel,

package/src/shell/externalLinks.js

@@ -35,14 +35,36 @@ export function httpLinkParts(value) {
   return parts.length > 0 ? parts : [{ text }];
 }
 
+// The label the operator actually reads. It used to be `[link: <hostname>]`,
+// which threw away the port and the path even when the whole URL fitted on the
+// line: `/openui` printing `http://localhost:3100` was displayed as
+// `[link: localhost]`, and nothing on screen said which port to open by hand.
+// Show the real URL, and shorten it only when it genuinely does not fit.
+export function linkLabel(url, width) {
+  const columns = Math.max(12, Number(width) || 12);
+  const text = String(url ?? '');
+  if (text.length <= columns) return text;
+  let host = '';
+  try {
+    // `host`, not `hostname`: the port is the part operators need most.
+    host = new URL(text).host;
+  } catch {
+    return text;
+  }
+  if (!host) return text;
+  const short = `${host}/…`;
+  // Never truncate below the host: a clipped `example.tes…` is unusable, while
+  // an overflowing host is still a real token the row simply clips.
+  return short.length <= columns ? short : host;
+}
+
 export function wrapHttpLinks(value, width) {
   const columns = Math.max(12, Number(width) || 12);
   const rows = [[]];
   let used = 0;
   for (const part of httpLinkParts(value)) {
     if (part.url) {
-      const parsed = new URL(part.url);
-      const label = `[link: ${parsed.hostname}]`;
+      const label = linkLabel(part.url, columns);
       if (used > 0 && used + label.length > columns) {
         rows.push([]);
         used = 0;