@dotdrelle/wiki-manager 0.15.26 → 0.15.28

package/src/shell/openExternal.js

@@ -0,0 +1,53 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+
+// `xdg-open` alone is not an opener strategy. It is absent from most container
+// and headless installs, and under WSL it either does not exist or opens a
+// Linux browser that nobody can see. Every failure used to be swallowed by an
+// empty callback, so clicking a link in the ShellUI did strictly nothing and
+// gave no reason why. Try the real candidates for the platform, in order.
+function openerCandidates() {
+  if (process.platform === 'darwin') return [['open', []]];
+  if (process.platform === 'win32') return [['cmd', ['/c', 'start', '']]];
+  const candidates = [];
+  // WSL: reach the Windows browser first, otherwise the URL opens in a Linux
+  // session the operator is not looking at.
+  if (process.env.WSL_DISTRO_NAME || existsSync('/proc/sys/fs/binfmt_misc/WSLInterop')) {
+    candidates.push(['wslview', []], ['/mnt/c/Windows/System32/cmd.exe', ['/c', 'start', '']]);
+  }
+  candidates.push(['xdg-open', []], ['gio', ['open']], ['sensible-browser', []]);
+  return candidates;
+}
+
+export function normalizeExternalUrl(value) {
+  const text = String(value ?? '').trim();
+  if (!text) return null;
+  try {
+    const parsed = new URL(text);
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return null;
+    // Validate, but hand back the operator's own string: `toString()` appends a
+    // root slash, so the hint would show `http://localhost:3100/` while the
+    // rendered line said `http://localhost:3100`. Safe because the URL is
+    // passed as an argv element, never through a shell.
+    return text;
+  } catch {
+    return null;
+  }
+}
+
+// Returns the opened URL, or null when no opener on this machine worked. The
+// caller is expected to fall back to something the operator can act on (copy
+// the URL, show it) rather than failing silently.
+export function openExternalUrl(value, { run = execFileSync } = {}) {
+  const url = normalizeExternalUrl(value);
+  if (!url) return null;
+  for (const [command, args] of openerCandidates()) {
+    try {
+      run(command, [...args, url], { stdio: 'ignore', timeout: 5_000 });
+      return url;
+    } catch {
+      // Missing binary or non-zero exit: try the next candidate.
+    }
+  }
+  return null;
+}

package/src/shell/repl.js

@@ -175,6 +175,32 @@ export function conversationMessages(session) {
   return session.conversations[key];
 }
 
+// Ordered from verifiable to hopeful. Mirrors tui.tsx's clipboardCommands():
+// xsel before xclip because xclip must keep running to own the X selection
+// and inherits our stdio, so execFileSync waits on pipes that never close
+// and hangs the whole shell; xsel forks and releases them.
+function clipboardCommands() {
+  if (process.platform === 'darwin') return [['pbcopy', []]];
+  if (process.platform === 'win32') return [['clip', []]];
+  return [
+    ['wl-copy', []],
+    ['xsel', ['--clipboard', '--input']],
+    ['xclip', ['-selection', 'clipboard']],
+  ];
+}
+
+function copyTextToClipboard(text) {
+  for (const [command, args] of clipboardCommands()) {
+    try {
+      execFileSync(command, args, { input: text, stdio: ['pipe', 'ignore', 'ignore'], timeout: 2_000 });
+      return true;
+    } catch {
+      // Missing binary, wrong display server, or timeout: try the next one.
+    }
+  }
+  return false;
+}
+
 function initialLegacyWelcomeMessage() {
   return [
     'Orchestrator agent ready.',
@@ -1500,7 +1526,10 @@ export async function runLine(line, { agent, packageJson, session, onUpdate, onS
   }
 
   if (trimmed.startsWith('/')) {
-    onStep?.(`Shell: ${trimmed}`);
+    // No command echo here: every caller already records the submitted line
+    // (`input: <line>` in useAgent, readline's own echo in the terminal REPL).
+    // Emitting `Shell: /status` on top produced two log rows for one keystroke,
+    // and only for slash commands — free text got a single row.
     const result = await handleSlashCommand(trimmed, { packageJson, session, onStep, runtime });
     const messages = conversationMessages(session);
     const handoffRawToAgent = Boolean(result.rawOutput && result.agentTrigger && agent);
@@ -1801,17 +1830,11 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
       const lastDonna = [...messages].reverse().find((m) => isDonnaRole(m.role));
       if (lastDonna) {
         const text = stripAnsi(colorizeStatus(lastDonna.content)).replace(/\[[0-9;]*m/g, '');
-        const clipCmd = process.platform === 'darwin'
-          ? { command: 'pbcopy', args: [] }
-          : { command: 'xclip', args: ['-selection', 'clipboard'] };
         const prevLabel = spinnerLabel;
         const prevBusy = busy;
-        try {
-          execFileSync(clipCmd.command, clipCmd.args, { input: text });
-          spinnerLabel = 'Copied to clipboard ✓';
-        } catch {
-          spinnerLabel = 'Copy failed — pbcopy / xclip not available';
-        }
+        spinnerLabel = copyTextToClipboard(text)
+          ? 'Copied to clipboard ✓'
+          : 'Copy failed — install wl-copy, xsel or xclip.';
         busy = true;
         rerender();
         setTimeout(() => { spinnerLabel = prevLabel; busy = prevBusy; rerender(); }, 1800);

package/src/shell/repl.test.js

@@ -21,7 +21,8 @@ import {
   submitRuntimeTurn,
 } from './repl.js';
 import { readFile } from 'node:fs/promises';
-import { httpLinkParts, wrapHttpLinks } from './externalLinks.js';
+import { httpLinkParts, linkLabel, wrapHttpLinks } from './externalLinks.js';
+import { normalizeExternalUrl, openExternalUrl } from './openExternal.js';
 
 test('ShellUI inserts StyledText as a child instead of stringifying it through content', async () => {
   const source = await readFile(new URL('./LeftPane.tsx', import.meta.url), 'utf8');
@@ -41,7 +42,39 @@ test('ShellUI renders the user header full-width before constraining only its bo
   assert.match(source.slice(userBodyBranch), /justifyContent="flex-start"/);
   assert.doesNotMatch(source.slice(userBodyBranch, source.indexOf(') : line.status ?', userBodyBranch)), /#12263A/);
   assert.doesNotMatch(source, /messageHeaderSegments\(message\.role, contentColumns\)/);
-  assert.match(source, /messageHeaderSegments\(message\.role, columns\)/);
+  // The third argument reserves room for [ redo ]; the width stays `columns`.
+  assert.match(source, /messageHeaderSegments\(message\.role, columns(, canRedo)?\)/);
+});
+
+test('redo is offered on user questions only, next to copy', async () => {
+  const source = await readFile(new URL('./LeftPane.tsx', import.meta.url), 'utf8');
+  assert.match(source, /const canRedo = message\.role === 'user' && raw\.trim\(\)\.length > 0;/);
+  assert.match(source, /props\.onRedo\?\.\(line\.redoIndex!, line\.redoContent!\)/);
+
+  const session = await readFile(new URL('./useSession.ts', import.meta.url), 'utf8');
+  // The runtime must be truncated first: its conversation is derived from the
+  // event log and would be merged straight back in otherwise.
+  const truncateIndex = session.indexOf('postRuntimeConversationTruncate(runtimeIndex');
+  const spliceIndex = session.indexOf('full.splice(index)');
+  const submitIndex = session.indexOf('return submitInput(content)');
+  assert.ok(truncateIndex > 0 && spliceIndex > truncateIndex && submitIndex > spliceIndex);
+  assert.match(session, /const windowOffset = Math\.max\(0, full\.length - messages\(\)\.length\);/);
+});
+
+test('redo translates the local thread index into a runtime conversation index', async () => {
+  const session = await readFile(new URL('./useSession.ts', import.meta.url), 'utf8');
+  const redo = session.slice(
+    session.indexOf('async function redoMessage('),
+    session.indexOf('function updateInput('),
+  );
+  // The local thread holds entries the runtime never recorded (slash-command
+  // output, help panels). Passing the raw local index to /conversation/truncate
+  // is what produced `index_out_of_range`; `backed` is the translation table.
+  assert.match(redo, /const backed = runtimeConversationRefsByWorkspace\.get\(workspaceKey\)/);
+  assert.match(redo, /let runtimeIndex = backed\.indexOf\(full\[index\]\)/);
+  assert.match(redo, /if \(full\.indexOf\(backed\[i\]\) < index\)/);
+  assert.match(redo, /props\.runtime\?\.url && runtimeIndex >= 0/);
+  assert.doesNotMatch(redo, /postRuntimeConversationTruncate\(index/);
 });
 
 test('ShellUI renders newest-first order in both Runtime and Agent status', async () => {
@@ -144,36 +177,101 @@ test('ShellUI turns HTTP URLs into valid links without trailing punctuation', ()
   ]);
 });
 
-test('long ShellUI URLs use one short label with the complete link target', () => {
+test('a link that fits is shown as the URL itself, never as a [link: host] stub', () => {
+  // `/openui` prints `Web UI: http://localhost:3100`. The old `[link: host]`
+  // label dropped the port, so a failed opener left nothing to type by hand.
+  const url = 'http://localhost:3100';
+  assert.equal(linkLabel(url, 60), url);
+  const links = wrapHttpLinks(`Web UI: ${url}`, 60).flat().filter((part) => part.url);
+  assert.deepEqual(links, [{ text: url, url }]);
+});
+
+test('long ShellUI URLs shorten to host, keeping the full link target', () => {
   const url = 'https://example.test/a/very/long/document';
   const links = wrapHttpLinks(url, 12).flat().filter((part) => part.url);
-  assert.deepEqual(links, [{ text: '[link: example.test]', url }]);
+  // Too narrow even for `host/…`: the host stays whole rather than being
+  // truncated into an unusable fragment.
+  assert.deepEqual(links, [{ text: 'example.test', url }]);
+  assert.equal(linkLabel('https://example.test:8443/a/very/long/document', 20), 'example.test:8443/…');
 });
 
 test('ShellUI makes rendered link lines openable with the system browser', async () => {
   const source = await readFile(new URL('./LeftPane.tsx', import.meta.url), 'utf8');
-  assert.match(source, /onMouseUp=\{\(\) => openSingleLineLink\(line\.segments\)\}/);
-  assert.match(source, /execFile\(opener, \[parsed\.toString\(\)\]/);
+  assert.match(source, /const url = singleLineUrl\(line\.segments\);/);
+  assert.match(source, /props\.onOpenLink\?\.\(url\)/);
+  // Hover feedback: nothing else on screen says a line is clickable.
+  assert.match(source, /onMouseOver=\{\(\) => hoverLink\(singleLineUrl\(line\.segments\)\)\}/);
+  assert.match(source, /onMouseOut=\{\(\) => hoverLink\(null\)\}/);
+  assert.match(source, /setMousePointer\?\.\(url \? 'pointer' : 'default'\)/);
 });
 
 test('ShellUI never splits a link label at the end of a line', () => {
   const url = 'https://example.test/a/very/long/document';
   const rows = wrapHttpLinks(`Voir maintenant ${url}`, 20);
   assert.equal(rows.length, 2);
-  assert.deepEqual(rows[1], [{ text: '[link: example.test]', url }]);
+  assert.deepEqual(rows[1], [{ text: 'example.test/…', url }]);
+});
+
+test('a slash command produces one activity row, not a duplicated echo', async () => {
+  const source = await readFile(new URL('./repl.js', import.meta.url), 'utf8');
+  // useAgent already logs `input: <line>` for every submission; repl.js used to
+  // add `Shell: <line>` on top, but only for slash commands.
+  assert.doesNotMatch(source, /onStep\?\.\(`Shell: \$\{trimmed\}`\)/);
+  const useAgent = await readFile(new URL('./useAgent.ts', import.meta.url), 'utf8');
+  assert.match(useAgent, /props\.addLog\(`input: \$\{trimmed\}`\)/);
+});
+
+test('clipboard copy prefers a verifiable local tool over fire-and-forget OSC 52', async () => {
+  const source = await readFile(new URL('./tui.tsx', import.meta.url), 'utf8');
+  const localIndex = source.indexOf('for (const [command, args] of clipboardCommands())');
+  const osc52Index = source.indexOf('copyToClipboardOSC52');
+  const osc52Call = source.indexOf('osc52.call(renderer, text)');
+  assert.ok(localIndex > 0 && osc52Call > localIndex, 'OSC 52 must be the last resort');
+  assert.ok(osc52Index > 0);
+  // xsel before xclip: xclip holds the X selection and never closes the
+  // inherited pipes, which froze the ShellUI under execFileSync.
+  assert.ok(source.indexOf("'xsel'") < source.indexOf("'xclip'"));
+  assert.match(source, /stdio: \['pipe', 'ignore', 'ignore'\]/);
+  assert.match(source, /timeout: 2_000/);
 });
 
 test('ShellUI leaves malformed URLs as plain text', () => {
   assert.deepEqual(httpLinkParts('Erreur: https://'), [{ text: 'Erreur: https://' }]);
 });
 
+test('opening a link tries every opener the platform offers before giving up', () => {
+  const attempts = [];
+  const failing = (command, args) => {
+    attempts.push([command, args.at(-1)]);
+    throw new Error('ENOENT');
+  };
+
+  // A single missing `xdg-open` used to swallow the click silently; the caller
+  // now learns that nothing worked and can fall back to copying the URL.
+  assert.equal(openExternalUrl('http://localhost:3100', { run: failing }), null);
+  assert.ok(attempts.length >= 1, 'expected at least one opener candidate');
+  assert.ok(attempts.every(([, url]) => url === 'http://localhost:3100'));
+
+  const calls = [];
+  const working = (command, args) => { calls.push(command); };
+  assert.equal(openExternalUrl('http://localhost:3100', { run: working }), 'http://localhost:3100');
+  assert.equal(calls.length, 1, 'must stop at the first opener that succeeds');
+});
+
+test('only http(s) targets ever reach the system opener', () => {
+  for (const value of ['file:///etc/passwd', 'javascript:alert(1)', 'not a url', '', null]) {
+    assert.equal(normalizeExternalUrl(value), null, `${value} must not be openable`);
+    assert.equal(openExternalUrl(value, { run: () => { throw new Error('must not run'); } }), null);
+  }
+});
+
 test('ShellUI preserves every URL when several links share one line', () => {
   const links = wrapHttpLinks('Docs https://one.example/a puis https://two.example/b', 80)
     .flat()
     .filter((part) => part.url);
   assert.deepEqual(links, [
-    { text: '[link: one.example]', url: 'https://one.example/a' },
-    { text: '[link: two.example]', url: 'https://two.example/b' },
+    { text: 'https://one.example/a', url: 'https://one.example/a' },
+    { text: 'https://two.example/b', url: 'https://two.example/b' },
   ]);
 });
 

package/src/shell/setupWizardPlaceholders.test.js

@@ -0,0 +1,66 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const wizardPath = fileURLToPath(new URL('./SetupWizard.tsx', import.meta.url));
+const scaffoldPath = fileURLToPath(
+  new URL('../../../llm-wiki/scaffold/workspace/.wikirc.yaml', import.meta.url),
+);
+
+function placeholderRegex() {
+  const source = readFileSync(wizardPath, 'utf8');
+  const match = source.match(/^const PLACEHOLDER_VALUE_RE = \/(.+)\/i;$/m);
+  assert.ok(match, 'PLACEHOLDER_VALUE_RE must stay a single-line literal the tests can read');
+  return new RegExp(match[1], 'i');
+}
+
+test('the wizard treats scaffolded config values as unset', { skip: !existsSync(scaffoldPath) && 'llm-wiki sibling checkout not available' }, () => {
+  const regex = placeholderRegex();
+  const scaffold = readFileSync(scaffoldPath, 'utf8');
+
+  // Cross-repo guard: if the scaffold ever ships a different fake endpoint or
+  // secret, the wizard would prefill it as a real answer and a skipped step
+  // would write it to the operator's config.
+  const placeholders = [
+    ...scaffold.matchAll(/^\s*(baseUrl|apiKey|model):\s*(\S+)\s*$/gm),
+  ].map(([, key, value]) => [key, value]);
+
+  assert.ok(placeholders.length >= 4, 'expected the scaffold to declare endpoints and secrets');
+  for (const [key, value] of placeholders) {
+    assert.match(value, regex, `scaffolded ${key}=${value} must be recognised as a placeholder`);
+  }
+});
+
+test('preloading a profile filters placeholders out of every prefilled field', () => {
+  const source = readFileSync(wizardPath, 'utf8');
+
+  for (const field of [
+    'baseUrl: configuredValue(config.llm.baseUrl)',
+    'apiKey: configuredValue(config.llm.apiKey)',
+    'model: configuredValue(config.llm.model)',
+    'baseUrl: configuredValue(config.retrieval.vector.baseUrl)',
+    'apiKey: configuredValue(config.retrieval.vector.apiKey)',
+  ]) {
+    assert.ok(source.includes(field), `preloadWikirc must filter ${field}`);
+  }
+
+  // With the vector URL filtered to null, this is what makes the embeddings
+  // step offer the base URL the operator just typed.
+  assert.match(source, /const baseUrl = vector\(\)\.baseUrl \|\| llm\(\)\.baseUrl;/);
+  assert.match(source, /baseUrl: old\.baseUrl \|\| llm\(\)\.baseUrl \|\| defaultBaseUrl\(llm\(\)\.provider\)/);
+});
+
+test('a real configuration is never mistaken for a placeholder', () => {
+  const regex = placeholderRegex();
+
+  for (const value of [
+    'https://albert.api.etalab.gouv.fr/v1',
+    'http://localhost:11434',
+    'https://api.openai.com',
+    'BAAI/bge-m3',
+    'gpt-oss-120b',
+  ]) {
+    assert.doesNotMatch(value, regex, `${value} must be kept as a configured value`);
+  }
+});

package/src/shell/tui.tsx

@@ -4,6 +4,7 @@ import { render, useKeyboard, useRenderer, useSelectionHandler, useTerminalDimen
 import { createMemo, createSignal, onCleanup, Show } from 'solid-js';
 import { FileEditorDialog } from './FileEditorDialog';
 import { LeftPane } from './LeftPane';
+import { openExternalUrl } from './openExternal.js';
 import { RightPane } from './RightPane';
 import { SlashDialog } from './SlashDialog';
 import { SetupWizard } from './SetupWizard';
@@ -74,35 +75,53 @@ function startupInfo(packageJson: Record<string, unknown>, preferredWorkspaceNam
   }
 }
 
+// Ordered from verifiable to hopeful. Each entry is [command, args].
+function clipboardCommands(): Array<[string, string[]]> {
+  if (process.platform === 'darwin') return [['pbcopy', []]];
+  if (process.platform === 'win32') return [['clip', []]];
+  return [
+    ['wl-copy', []],
+    // `xsel` before `xclip`: xclip must keep running to own the X selection and
+    // inherits our stdio, so execFileSync waits on pipes that never close and
+    // the whole ShellUI freezes. xsel forks and releases them.
+    ['xsel', ['--clipboard', '--input']],
+    ['xclip', ['-selection', 'clipboard']],
+  ];
+}
+
 function copyToClipboard(text: string, renderer: unknown) {
-  try {
-    const osc52 = (renderer as any).copyToClipboardOSC52;
-    if (typeof osc52 === 'function') {
-      osc52.call(renderer, text);
+  // Local tools first, OSC 52 last. OSC 52 used to win by default and always
+  // reported success, because writing an escape sequence cannot fail: on
+  // GNOME Terminal / VTE, which does not implement it, the sequence was
+  // swallowed and the ShellUI cheerfully announced "Copied." with an unchanged
+  // clipboard. Selection-copy appeared to work only because the terminal
+  // itself copies selections, without going through this code at all.
+  for (const [command, args] of clipboardCommands()) {
+    try {
+      execFileSync(command, args, {
+        input: text,
+        // Never inherit stdout/stderr: see the xclip note above.
+        stdio: ['pipe', 'ignore', 'ignore'],
+        timeout: 2_000,
+      });
       return true;
+    } catch {
+      // Missing binary, wrong display server, or timeout: try the next one.
     }
-  } catch {
-    // Fall through to platform clipboard tools.
   }
+  // Nothing local worked. Over SSH or in a terminal that supports it, OSC 52
+  // is the only remaining option — but it is fire-and-forget, so it is also
+  // the only case where we cannot promise the clipboard was actually written.
   try {
-    if (process.platform === 'darwin') {
-      execFileSync('pbcopy', [], { input: text });
-      return true;
-    }
-    if (process.platform === 'win32') {
-      execFileSync('clip', [], { input: text });
-      return true;
-    }
-    try {
-      execFileSync('wl-copy', [], { input: text });
-      return true;
-    } catch {
-      execFileSync('xclip', ['-selection', 'clipboard'], { input: text });
+    const osc52 = (renderer as any).copyToClipboardOSC52;
+    if (typeof osc52 === 'function') {
+      osc52.call(renderer, text);
       return true;
     }
   } catch {
-    return false;
+    // Renderer without OSC 52 support.
   }
+  return false;
 }
 
 function App(props: {
@@ -326,10 +345,6 @@ function App(props: {
       }, 1600);
       return;
     }
-    if (key.ctrl && keyName === 'q') {
-      state.toggleRightTab();
-      return;
-    }
     if (state.busy()) return;
     if (keyName === 'tab') state.completeSelected();
     if (keyName === 'pageup') state.scrollConversation(conversationRows());
@@ -383,7 +398,21 @@ function App(props: {
             scrollConversation={state.scrollConversation}
             spinnerFrame={SPINNER_FRAMES[spinnerIndex()] ?? SPINNER_FRAMES[0]}
             onInputHeightChange={setChatInputHeight}
-            onCopy={(content) => showCopyHint(copyToClipboard(content, renderer) ? 'Copied.' : 'Copy failed.')}
+            onRedo={(index, content) => { void state.redoMessage(index, content); }}
+            onCopy={(content) => showCopyHint(
+              copyToClipboard(content, renderer)
+                ? 'Copied.'
+                // Actionable, because the fix is one package away: on Linux the
+                // clipboard needs wl-copy (Wayland) or xsel/xclip (X11).
+                : 'Copy failed — install wl-copy, xsel or xclip.',
+            )}
+            onOpenLink={(url) => {
+              if (openExternalUrl(url)) return showCopyHint(`Opening ${url}`);
+              // No usable opener on this machine (headless, container, no
+              // xdg-utils). Leave the operator something actionable instead of
+              // the silent no-op that made links look broken.
+              showCopyHint(copyToClipboard(url, renderer) ? `No browser opener — copied ${url}` : `No browser opener — open ${url}`);
+            }}
           />
           <box width={1} height="100%" flexDirection="column">
             {Array.from({ length: dimensions().height }, () => (

package/src/shell/useSession.ts

@@ -9,7 +9,7 @@ import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { projectQueue, queueCounts, startNextQueuedJob, syncQueueWithActivity } from '../core/jobQueue.js';
 import { queueStoreFor } from '../core/queueStore.js';
 import { filterRuntimeLogs } from '../core/runtimeLog.js';
-import { fetchRuntimeState, streamRuntimeEvents } from '../runtime/client.js';
+import { fetchRuntimeState, postRuntimeConversationTruncate, streamRuntimeEvents } from '../runtime/client.js';
 import type { ActiveFileEditor } from './FileEditorDialog';
 import {
   completionContext,
@@ -656,6 +656,63 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     return result;
   }
 
+  // Redo: re-ask one question after discarding everything it produced.
+  // `displayIndex` indexes the rendered (windowed) list, so it is translated
+  // back to the full conversation before anything is deleted — otherwise a
+  // scrolled-back redo would truncate at the wrong message.
+  async function redoMessage(displayIndex: number, content: string) {
+    if (conversationBusy()) return { exit: false, busy: true };
+    const full = conversationMessages(session);
+    const windowOffset = Math.max(0, full.length - messages().length);
+    const index = windowOffset + displayIndex;
+    if (index < 0 || index >= full.length) return { exit: false };
+
+    const workspaceKey = (session as any).workspace || '__global__';
+    // The local thread and the runtime conversation are NOT the same list:
+    // slash-command output, help panels and any other local-only entry live in
+    // `full` but were never recorded as events. Sending a `full` index straight
+    // to /conversation/truncate therefore points at the wrong entry — or past
+    // the end (`index_out_of_range`) — as soon as one local entry precedes the
+    // redone question. `backed` is index-aligned with the runtime conversation,
+    // so it is the only correct translation table.
+    const backed = runtimeConversationRefsByWorkspace.get(workspaceKey) ?? [];
+    let runtimeIndex = backed.indexOf(full[index]);
+    if (runtimeIndex === -1) {
+      // Local-only entry: truncate after the last runtime-backed entry that
+      // still precedes it, so nothing recorded before the question is lost.
+      for (let i = backed.length - 1; i >= 0; i -= 1) {
+        if (full.indexOf(backed[i]) < index) { runtimeIndex = i; break; }
+      }
+    }
+
+    if (props.runtime?.url && runtimeIndex >= 0) {
+      // The runtime derives the conversation from its event log: deleting
+      // locally alone would be undone by the next /state merge.
+      const result = await postRuntimeConversationTruncate(runtimeIndex, {
+        url: props.runtime.url,
+        workspace: (session as any).workspace ?? null,
+      }) as { truncated?: boolean; reason?: string };
+      if (result?.truncated !== true) {
+        addLog(result?.reason === 'run_active'
+          ? 'redo: a run is still active — cancel it first'
+          : result?.reason === 'workspace_required'
+            ? 'redo: select a workspace first'
+            : `redo: runtime refused to truncate (${result?.reason ?? 'unknown'})`);
+        return { exit: false };
+      }
+    }
+    // Drop the question too: resubmitting re-appends it, and keeping it here
+    // would leave the same message twice in the thread.
+    full.splice(index);
+    // Only the current workspace's merge state was invalidated by the
+    // truncate above — clearing every workspace's refs here would desync
+    // other workspaces' `backed` arrays from their untouched `target`
+    // arrays and duplicate their history on the next merge.
+    runtimeConversationRefsByWorkspace.get(workspaceKey)?.splice(0);
+    refresh();
+    return submitInput(content);
+  }
+
   function updateInput(value: string) {
     setInput(value);
     if (value !== dismissedSlashInput()) setDismissedSlashInput(null);
@@ -708,10 +765,6 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     setConversationScroll((value) => Math.max(0, value + delta));
   }
 
-  function toggleRightTab() {
-    setRightTab((value) => value === 'plan' ? 'queue' : 'plan');
-  }
-
   function selectRightTab(tab: 'plan' | 'queue') {
     setRightTab(tab);
   }
@@ -771,7 +824,6 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     queueItems,
     queueInfo,
     rightTab,
-    toggleRightTab,
     selectRightTab,
     plan,
     runSummary,
@@ -783,6 +835,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     busy: agentBusy,
     abort,
     submitInput,
+    redoMessage,
     completeSelected,
     dismissSlash,
     moveCompletion,