singleton-pipeline 0.4.0-beta.1 → 0.4.0-beta.13

package/packages/cli/src/index.js

@@ -22,7 +22,7 @@ function groupAgentsByProvider(agents) {
 program
   .name('singleton')
   .description('Singleton Pipeline Builder — scan agents and build pipelines')
-  .version('0.4.0-beta.1');
+  .version('0.4.0-beta.12');
 
 program
   .command('scan')

package/packages/cli/src/runners/claude.js

@@ -1,4 +1,4 @@
-import { spawn } from 'node:child_process';
+import spawn from 'cross-spawn';
 
 const DEFAULT_TIMEOUT_MS = Number(process.env.SINGLETON_RUNNER_TIMEOUT_MS) || 10 * 60 * 1000;
 const ALLOWED_PERMISSION_MODES = new Set(['bypassPermissions']);
@@ -97,8 +97,11 @@ export const claudeRunner = {
         }
       });
 
-      child.stdin.write(userPrompt);
-      child.stdin.end();
+      child.stdin.on('error', () => { /* surfaced via close handler */ });
+      try {
+        child.stdin.write(userPrompt);
+        child.stdin.end();
+      } catch { /* same */ }
     });
 
     return {

package/packages/cli/src/runners/codex.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { spawn } from 'node:child_process';
+import spawn from 'cross-spawn';
 import { discoverCodexProjectInstructions } from './codex-instructions.js';
 import { findUsage, safeJsonParse } from './_shared.js';
 
@@ -128,8 +128,11 @@ export const codexRunner = {
         resolve({ events, stderr: stderrText });
       });
 
-      child.stdin.write(prompt);
-      child.stdin.end();
+      child.stdin.on('error', () => { /* surfaced via close handler */ });
+      try {
+        child.stdin.write(prompt);
+        child.stdin.end();
+      } catch { /* same */ }
     });
 
     let text = '';

package/packages/cli/src/runners/copilot.js

@@ -1,4 +1,4 @@
-import { spawn } from 'node:child_process';
+import spawn from 'cross-spawn';
 import path from 'node:path';
 import { extractText, safeJsonParse } from './_shared.js';
 
@@ -56,10 +56,15 @@ export function buildCopilotPermissionArgs(securityPolicy = {}) {
     args.push('--allow-tool=write');
   }
 
+  // Copilot CLI runs in deny-by-default mode as soon as any --allow-tool is
+  // present. Agents need shell access to list/grep the codebase even when their
+  // write surface is restricted — otherwise the scout can't discover anything.
+  // read-only stays shell-less; dangerous is already covered by --allow-all-tools.
   if (profile === 'read-only') {
     args.push('--deny-tool=write');
     args.push('--deny-tool=shell');
   } else {
+    if (profile !== 'dangerous') args.push('--allow-tool=shell');
     args.push('--deny-tool=shell(git push)');
   }
 
@@ -77,9 +82,14 @@ export function buildCopilotPermissionArgs(securityPolicy = {}) {
 }
 
 export function buildCopilotArgs({ prompt, model, runnerAgent, securityPolicy = {} } = {}) {
+  // Copilot CLI expects the user prompt as `-p <text>` arg. Passing `-p -` is
+  // interpreted as the literal string "-", not as a stdin marker, so we always
+  // inline the prompt as an argument here. Callers must keep the prompt under
+  // ~32KB on Windows — large blobs (scout output, etc.) should be referenced
+  // as files on disk rather than injected inline.
   const args = [
     '-p',
-    prompt,
+    prompt ?? '',
     '--output-format',
     'json',
     ...buildCopilotPermissionArgs(securityPolicy),
@@ -90,10 +100,13 @@ export function buildCopilotArgs({ prompt, model, runnerAgent, securityPolicy =
 }
 
 export function summarizeCopilotEvents(events) {
-  const assistantMessages = events
-    .filter((event) => event.type === 'assistant.message')
-    .map((event) => extractText(event.data))
-    .filter(Boolean);
+  // Copilot emits intermediate `assistant.message` events between tool calls
+  // (the model's "thinking out loud"). The final deliverable is the LAST
+  // assistant.message — concatenating them all would prepend narration noise
+  // to whatever the agent is supposed to produce as its output.
+  const assistantMessages = events.filter((event) => event.type === 'assistant.message');
+  const finalMessage = assistantMessages.at(-1);
+  const finalText = finalMessage ? extractText(finalMessage.data) : '';
   const deltaText = events
     .filter((event) => event.type === 'assistant.message_delta')
     .map((event) => event.data?.deltaContent || event.data?.delta || '')
@@ -106,8 +119,8 @@ export function summarizeCopilotEvents(events) {
   }, 0);
 
   return {
-    text: assistantMessages.join('\n').trim() || deltaText.trim(),
-    turns: events.filter((event) => event.type === 'assistant.message').length || null,
+    text: (finalText || deltaText).trim(),
+    turns: assistantMessages.length || null,
     outputTokens: outputTokens || null,
     premiumRequests: Number(result?.usage?.premiumRequests || 0) || null,
     result,
@@ -137,7 +150,10 @@ export const copilotRunner = {
     securityPolicy,
     timeoutMs = DEFAULT_TIMEOUT_MS,
   }) {
-    const prompt = buildPrompt(systemPrompt, userPrompt);
+    // When --agent is used, Copilot loads the system prompt from .github/agents/<name>.md.
+    // We pass only the user prompt as `-p <text>`. Without --agent we inline the
+    // system prompt wrapped in <system>/<user> tags as the user prompt.
+    const prompt = runnerAgent ? userPrompt : buildPrompt(systemPrompt, userPrompt);
     const args = buildCopilotArgs({ prompt, model, runnerAgent, securityPolicy });
 
     const { events, stderr } = await new Promise((resolve, reject) => {

package/packages/cli/src/runners/opencode.js

@@ -1,4 +1,4 @@
-import { spawn } from 'node:child_process';
+import spawn from 'cross-spawn';
 import path from 'node:path';
 import { extractText, findCostUsd, findUsage, safeJsonParse } from './_shared.js';
 

package/packages/cli/src/shell.js

@@ -13,6 +13,30 @@ export const C = {
   ghost:   '#797C81',   // gris discret lisible sur fond sombre
 };
 
+// ── Semantic tokens — one color, one role ────────────────────────
+// Use these everywhere. Each token carries meaning, not decoration.
+//   text     — primary readable body text
+//   muted    — secondary text, metadata (dates, versions, descriptions)
+//   subtle   — decorative separators (·, ─)
+//   accent   — brand, interactive elements (slash commands, agent IDs)
+//   keyword  — technical labels and feature/provider names
+//   string   — user data (pipeline names, paths, URLs)
+//   success  — positive markers (✓), confirmations
+//   warning  — attention markers (!), announcements (New)
+//   error    — failure markers (✕), blocking errors
+export const S = {
+  text:    '#FFFFFF',
+  muted:   '#8E8B9E',   // soft cool gray, very subtly violet-tinted — reads as "quiet"
+  subtle:  '#797C81',
+  border:  '#4A4060',   // structural separators (blessed.line widgets, frames)
+  accent:  '#C084FC',
+  keyword: '#93C5FD',
+  string:  '#F9A8D4',
+  success: '#6EE7B7',
+  warning: '#FDBA74',
+  error:   '#FCA5A5',
+};
+
 export function createShell() {
   const screen = blessed.screen({ smartCSR: true, title: 'Singleton' });
   const inputHints = [
@@ -29,10 +53,12 @@ export function createShell() {
     width: '100%', height: '100%-4',
     scrollable: true, alwaysScroll: true,
     tags: true,
-    padding: { left: 2, top: 1, right: 2 },
+    border: { type: 'line' },
+    style: { border: { fg: S.border } },
+    padding: { left: 1, top: 0, right: 1 },
     scrollbar: {
       ch: '│',
-      style: { fg: C.line }
+      style: { fg: S.border }
     }
   });
 
@@ -44,32 +70,36 @@ export function createShell() {
     hidden: true,
     scrollable: true,
     alwaysScroll: true,
-    padding: { left: 2, top: 1, right: 2 },
+    border: { type: 'line' },
+    style: { border: { fg: S.border } },
+    padding: { left: 1, top: 0, right: 1 },
     scrollbar: {
       ch: '│',
-      style: { fg: C.line }
+      style: { fg: S.border }
     }
   });
 
-  const pipelineSep = blessed.line({
-    orientation: 'horizontal',
-    bottom: 8, left: 0, width: '100%',
-    style: { fg: C.line }
-  });
-
   const pipelineStatus = blessed.box({
-    bottom: 4, left: 0,
+    bottom: 5, left: 0,
     width: '100%', height: 4,
     tags: true,
     hidden: true,
     padding: { left: 2, right: 2 }
   });
 
+  // Label overlay sitting on the top border of pipelineLog (e.g. "Step 2/4" or "input waiting")
+  const pipelineLabel = blessed.box({
+    top: 0, left: 4,
+    width: 'shrink', height: 1,
+    tags: true,
+    hidden: true
+  });
+
   // ── Shell bar (toujours visible) ───────────────────────────────
   const sep1 = blessed.line({
     orientation: 'horizontal',
     bottom: 3, left: 0, width: '100%',
-    style: { fg: C.line }
+    style: { fg: S.border }
   });
 
   const suggestBox = blessed.box({
@@ -90,7 +120,7 @@ export function createShell() {
   const sep2 = blessed.line({
     orientation: 'horizontal',
     bottom: 1, left: 0, width: '100%',
-    style: { fg: C.line }
+    style: { fg: S.border }
   });
 
   const footerLeftBox = blessed.box({
@@ -116,8 +146,8 @@ export function createShell() {
 
   screen.append(content);
   screen.append(pipelineLog);
-  screen.append(pipelineSep);
   screen.append(pipelineStatus);
+  screen.append(pipelineLabel);
   screen.append(suggestBox);
   screen.append(sep1);
   screen.append(promptBox);
@@ -126,7 +156,6 @@ export function createShell() {
   screen.append(footerRightBox);
   screen.append(footerCenterBox);
 
-  pipelineSep.hide();
   pipelineStatus.hide();
 
   // ── Input state ─────────────────────────────────────────────────
@@ -146,6 +175,9 @@ export function createShell() {
   let footerLeft = '';
   let footerRight = '';
   let footerCenter = '';
+  // Tracks the /run two-step submit: first Enter on `/run <pipeline>` opens flag suggestions
+  // passively, second Enter submits. Cleared by any keystroke that breaks the dance.
+  let runAwaitingSecondEnter = false;
   function stripTags(s) {
     return String(s || '').replace(/\{[^}]+\}/g, '');
   }
@@ -157,7 +189,7 @@ export function createShell() {
   }
 
   function renderSuggestions() {
-    if (!suggestions.length || promptMode) {
+    if (!suggestions.length) {
       suggestBox.hide();
       return;
     }
@@ -168,13 +200,18 @@ export function createShell() {
       Math.max(0, suggestions.length - maxItems)
     );
     const width = Math.max(40, (screen.width ?? 100) - 6);
+    // Semantic styling:
+    //   active row   → accent ›, white bold label, muted description (clearly the one in focus)
+    //   inactive row → blank marker, muted label, subtle description (recedes)
+    // suggestIndex === -1 means "no active selection" (passive listing after a soft Enter on /run).
     const lines = suggestions.slice(start, start + maxItems).map((item, idx) => {
-      const active = start + idx === suggestIndex;
-      const marker = active ? `{${C.violet}-fg}›{/}` : `{${C.ghost}-fg} {/}`;
+      const active = suggestIndex >= 0 && start + idx === suggestIndex;
+      const marker = active ? `{${S.accent}-fg}{bold}›{/}` : ' ';
       const label = active
-        ? `{${C.pink}-fg}${item.label}{/}`
-        : `{${C.dimV}-fg}${item.label}{/}`;
-      const desc = item.description ? ` {${C.ghost}-fg}${item.description}{/}` : '';
+        ? `{${S.text}-fg}{bold}${item.label}{/}`
+        : `{${S.muted}-fg}${item.label}{/}`;
+      const descColor = active ? S.muted : S.subtle;
+      const desc = item.description ? ` {${descColor}-fg}${item.description}{/}` : '';
       const visible = stripTags(`${marker} ${item.label}${item.description ? ` ${item.description}` : ''}`);
       const clippedDesc = visible.length > width ? '' : desc;
       return `${marker} ${label}${clippedDesc}`;
@@ -184,17 +221,21 @@ export function createShell() {
     suggestBox.show();
   }
 
-  async function refreshSuggestions({ applySingle = false } = {}) {
-    if (!completer || promptMode) return false;
+  async function refreshSuggestions({ applySingle = false, passive = false } = {}) {
+    // Prompt-scoped completer (set via shell.prompt({ completer })) takes precedence,
+    // so per-field autocompletes don't leak into the global slash-command completer.
+    const activeCompleter = promptMode?.completer || completer;
+    if (!activeCompleter) return false;
 
     const seq = ++completeSeq;
-    const result = await completer({ buffer, cursor: buffer.length });
+    const result = await activeCompleter({ buffer, cursor: buffer.length });
     if (seq !== completeSeq) return false;
 
     suggestions = Array.isArray(result)
       ? result.filter((s) => s && typeof s.value === 'string' && typeof s.label === 'string')
       : [];
-    suggestIndex = 0;
+    // passive=true: shown as a list with no active row; Enter will submit, not apply.
+    suggestIndex = passive ? -1 : 0;
 
     if (applySingle && suggestions.length === 1) {
       applySuggestion(suggestions[0]);
@@ -210,6 +251,7 @@ export function createShell() {
     if (!item) return false;
     buffer = item.value;
     hideSuggestions();
+    runAwaitingSecondEnter = false;
     updatePrompt();
     return true;
   }
@@ -217,21 +259,29 @@ export function createShell() {
   function updatePrompt() {
     if (promptMode) {
       const message = String(promptMode.message || '');
+      // If the caller passed pre-tagged content, respect it. Otherwise the message
+      // belongs to the "awaiting input" state → bold + warning to match the ambient frame.
       const renderedMessage = message.includes('{')
         ? message
-        : `{${C.dimV}-fg}${message}{/}`;
+        : `{${S.warning}-fg}{bold}${message}{/}`;
       const marker = message.includes('Debug action')
         ? ''
-        : `{${C.pink}-fg}?{/}  `;
+        : `{${S.warning}-fg}{bold}?{/}  `;
+      // Ghost-text default: when the buffer is empty and the caller supplied a
+      // `default` value, render it in subtle after the cursor so it reads as a
+      // suggestion. Pressing Enter on an empty buffer accepts the default.
+      const ghost = (!buffer && promptMode.default)
+        ? `{${S.subtle}-fg}${promptMode.default}{/}`
+        : '';
       promptBox.setContent(
-        `${marker}${renderedMessage}  {${C.dimV}-fg}›{/}  ${buffer}{${C.violet}-fg}▌{/}`
+        `${marker}${renderedMessage}  {${S.muted}-fg}›{/}  ${buffer}{${S.accent}-fg}▌{/}${ghost}`
       );
     } else {
       if (buffer) {
-        promptBox.setContent(`{${C.dimV}-fg}›{/}  ${buffer}{${C.violet}-fg}▌{/}`);
+        promptBox.setContent(`{${S.muted}-fg}›{/}  ${buffer}{${S.accent}-fg}▌{/}`);
       } else {
         const hint = history.length === 0 ? inputHints[0] : inputHints[hintIndex];
-        promptBox.setContent(`{${C.dimV}-fg}›{/}  {${C.violet}-fg}▌{/}{#797C81-fg}${hint}{/}`);
+        promptBox.setContent(`{${S.muted}-fg}›{/}  {${S.accent}-fg}▌{/}{${S.subtle}-fg}${hint}{/}`);
       }
     }
     screen.render();
@@ -348,18 +398,26 @@ export function createShell() {
     if (!inputEnabled && !promptMode) return;
 
     if (promptMode && key.name === 'escape') {
-      const { resolve, message } = promptMode;
+      // In a prompt with autocomplete open, Esc first closes the suggestions instead
+      // of cancelling the prompt itself (matches the global-mode behavior).
+      if (suggestions.length) {
+        hideSuggestions();
+        updatePrompt();
+        return;
+      }
+      const { resolve, message, silent } = promptMode;
       promptMode = null;
       buffer = '';
-      log(`{${C.ghost}-fg}↩ cancelled{/} {${C.dimV}-fg}${message}{/}`);
+      if (!silent) log(`{${S.subtle}-fg}↩ cancelled{/} {${S.muted}-fg}${message}{/}`);
       updatePrompt();
       resolve('__SINGLETON_ESC__');
       return;
     }
 
-    if (!promptMode && key.name === 'tab') {
+    if (key.name === 'tab' && (promptMode?.completer || (!promptMode && completer))) {
       if (suggestions.length > 1) {
-        suggestIndex = (suggestIndex + 1) % suggestions.length;
+        // From the passive -1 state, Tab focuses the first item rather than skipping it.
+        suggestIndex = suggestIndex < 0 ? 0 : (suggestIndex + 1) % suggestions.length;
         renderSuggestions();
         screen.render();
         return;
@@ -368,9 +426,11 @@ export function createShell() {
       return;
     }
 
-    if (!promptMode && suggestions.length && (key.name === 'down' || key.name === 'up')) {
+    if (suggestions.length && (key.name === 'down' || key.name === 'up')) {
       const dir = key.name === 'down' ? 1 : -1;
-      suggestIndex = (suggestIndex + dir + suggestions.length) % suggestions.length;
+      // From the passive -1 state, the first arrow lands on item 0 (down) or last (up).
+      if (suggestIndex < 0) suggestIndex = dir === 1 ? 0 : suggestions.length - 1;
+      else suggestIndex = (suggestIndex + dir + suggestions.length) % suggestions.length;
       renderSuggestions();
       screen.render();
       return;
@@ -382,9 +442,14 @@ export function createShell() {
       return;
     }
 
-    if (!promptMode && suggestions.length && (key.name === 'right' || key.name === 'enter' || key.name === 'return')) {
-      applySuggestion();
-      return;
+    if (suggestions.length && (key.name === 'right' || key.name === 'enter' || key.name === 'return')) {
+      // Passive listing (no active row) → Enter falls through to the submit handler below.
+      if (suggestIndex < 0 && (key.name === 'enter' || key.name === 'return')) {
+        // fall through
+      } else {
+        applySuggestion();
+        return;
+      }
     }
 
     if (!promptMode && !suggestions.length && (key.full === 'C-p' || key.full === 'C-n')) {
@@ -415,14 +480,34 @@ export function createShell() {
 
     if (key.name === 'enter' || key.name === 'return') {
       const value = buffer.trim();
+
+      // Two-step submit for /run <pipeline>: first Enter opens flag suggestions passively,
+      // second Enter submits. Guarded by runAwaitingSecondEnter so dismissing the suggestions
+      // (Esc) and pressing Enter again doesn't re-loop.
+      if (
+        !promptMode &&
+        !runAwaitingSecondEnter &&
+        /^\/run\s+\S+\s*$/.test(value) &&
+        !value.includes(' --')
+      ) {
+        if (!buffer.endsWith(' ')) buffer += ' ';
+        runAwaitingSecondEnter = true;
+        updatePrompt();
+        await refreshSuggestions({ passive: true });
+        return;
+      }
+      runAwaitingSecondEnter = false;
+
       buffer = '';
       hideSuggestions();
       if (promptMode) {
-        const { resolve, message } = promptMode;
+        const { resolve, message, silent, default: promptDefault } = promptMode;
+        // Empty submission with a ghost-text default → resolve with the default.
+        const finalValue = (value === '' && promptDefault) ? promptDefault : value;
         promptMode = null;
-        log(`{${C.pink}-fg}?{/}  {${C.dimV}-fg}${message}{/}  ${value}`);
+        if (!silent) log(`{${S.warning}-fg}{bold}?{/}  {${S.muted}-fg}${message}{/}  ${finalValue}`);
         updatePrompt();
-        resolve(value);
+        resolve(finalValue);
       } else {
         updatePrompt();
         if (value) {
@@ -436,14 +521,28 @@ export function createShell() {
       }
     } else if (key.name === 'backspace') {
       buffer = buffer.slice(0, -1);
-      hideSuggestions();
       resetHistoryNav();
-      updatePrompt();
+      runAwaitingSecondEnter = false;
+      // In a prompt with a completer, keystrokes re-filter the suggestions instead
+      // of dismissing them. In all other modes, typing hides the suggest panel.
+      if (promptMode?.completer) {
+        updatePrompt();
+        await refreshSuggestions({ passive: true });
+      } else {
+        hideSuggestions();
+        updatePrompt();
+      }
     } else if (ch && !key.ctrl && !key.meta) {
       buffer += ch;
-      hideSuggestions();
       resetHistoryNav();
-      updatePrompt();
+      runAwaitingSecondEnter = false;
+      if (promptMode?.completer) {
+        updatePrompt();
+        await refreshSuggestions({ passive: true });
+      } else {
+        hideSuggestions();
+        updatePrompt();
+      }
     }
   });
 
@@ -454,14 +553,75 @@ export function createShell() {
 
   updatePrompt();
 
+  // Mode → border color mapping. Drives the "ambient state" frame around the log panel.
+  //   null/'idle'    → S.border (faint, structural)
+  //   'running'      → S.keyword (blue, run in progress)
+  //   'awaiting'     → S.warning (orange, waiting for human input)
+  //   'error'        → S.error (red, last run failed)
+  //   'debug'        → S.warning (orange, debug mode active)
+  // Label overlay shown on the top border of the pipeline log frame.
+  // Timeline writes the step indicator (step X/N). The executor can override
+  // with "input waiting" while a prompt is pending — overrides are sticky
+  // until cleared, so the timeline's spinner-tick re-renders don't clobber them.
+  let pipelineLabelOverride = null;
+  function writePipelineLabel(text) {
+    if (!text) {
+      pipelineLabel.setContent('');
+      pipelineLabel.hide();
+    } else {
+      pipelineLabel.setContent(` ${text} `);
+      pipelineLabel.show();
+    }
+    screen.render();
+  }
+  function applyPipelineLabel(text) {
+    if (pipelineLabelOverride !== null) return;
+    writePipelineLabel(text);
+  }
+  function setPipelineLabel(text) {
+    pipelineLabelOverride = text;
+    writePipelineLabel(`{${S.warning}-fg}{bold}${text}{/}`);
+  }
+  function clearPipelineLabel() {
+    pipelineLabelOverride = null;
+    writePipelineLabel('');
+  }
+
+  // Mode → border color. Two-layer state:
+  //   baseMode  — ambient mode set by the executor ('running' during a step, etc.)
+  //   currentMode — what is actually painted; prompts override to 'awaiting' and restore baseMode on resolve.
+  // Removed 'debug' as its own mode: a debug pause IS an awaiting state, a running debug step IS running.
+  let baseMode = null;
+  function applyMode(mode) {
+    const map = {
+      running:  S.keyword,
+      awaiting: S.warning,
+      error:    S.error,
+    };
+    const color = map[mode] || S.border;
+    content.style.border.fg = color;
+    pipelineLog.style.border.fg = color;
+    sep1.style.fg = color;
+    sep2.style.fg = color;
+    screen.render();
+  }
+  function setMode(mode) {
+    baseMode = mode;
+    applyMode(mode);
+  }
+
   return {
     log,
-    logMuted(text)  { log(`{${C.dimV}-fg}${text}{/}`); },
-    logAccent(text) { log(`{${C.violet}-fg}${text}{/}`); },
+    logMuted(text)  { log(`{${S.muted}-fg}${text}{/}`); },
+    logAccent(text) { log(`{${S.accent}-fg}${text}{/}`); },
     setFooter,
     setFooterCenter,
+    setMode,
+    setPipelineLabel,
+    clearPipelineLabel,
 
     clear() { content.setContent(''); screen.render(); },
+    setContent(text) { content.setContent(text); screen.render(); },
     onCommand(fn)  { onSubmit = fn; },
     setCompleter(fn) { completer = fn; },
 
@@ -499,17 +659,45 @@ export function createShell() {
     disableInput() { inputEnabled = false; hideSuggestions(); resetHistoryNav(); screen.render(); },
     enableInput()  { inputEnabled = true; buffer = ''; hideSuggestions(); resetHistoryNav(); updatePrompt(); },
 
-    prompt(message) {
+    prompt(message, { silent = false, completer: promptCompleter = null, default: promptDefault = '' } = {}) {
       return new Promise((resolve) => {
-        promptMode = { resolve, message };
+        // Override ambient mode to 'awaiting' (orange) for the duration of the prompt,
+        // and restore the baseMode (e.g. 'running') once the user has answered.
+        const shouldOverride = baseMode === 'running';
+        if (shouldOverride) applyMode('awaiting');
+        promptMode = {
+          message,
+          silent,
+          completer: promptCompleter,
+          default: promptDefault,
+          resolve: (value) => {
+            if (shouldOverride) applyMode(baseMode);
+            resolve(value);
+          },
+        };
         buffer = '';
         hideSuggestions();
         resetHistoryNav();
         updatePrompt();
+        // With a prompt-scoped completer, show the full suggestion list immediately
+        // so the user sees what's available without having to press Tab first.
+        // Use passive mode so Enter submits the typed value rather than applying
+        // the first row — Tab/arrows are the explicit "pick" path.
+        if (promptCompleter) {
+          refreshSuggestions({ passive: true }).catch(() => {});
+        }
       });
     },
 
-    pipelineWidgets: { screen, logPanel: pipelineLog, statusBox: pipelineStatus },
+    // Mirror sends every timeline.log call into the main `content` widget too, so the full
+    // run history survives exitPipelineMode (pipelineLog gets hidden, but content keeps it).
+    pipelineWidgets: {
+      screen,
+      logPanel: pipelineLog,
+      statusBox: pipelineStatus,
+      setLabel: applyPipelineLabel,
+      mirror: (text) => content.log(text),
+    },
 
     enterPipelineMode() {
       pipelineMode = true;
@@ -517,17 +705,19 @@ export function createShell() {
       pipelineLog.setContent('');
       pipelineStatus.setContent('');
       pipelineLog.show();
-      pipelineSep.show();
       pipelineStatus.show();
-      promptBox.setContent(`{${C.dimV}-fg}scroll: ↑ ↓ pgup pgdn home end{/}`);
+      pipelineLabel.show();
+      promptBox.setContent('');
       screen.render();
     },
 
     exitPipelineMode() {
       pipelineMode = false;
+      pipelineLabelOverride = null;
       pipelineLog.hide();
-      pipelineSep.hide();
       pipelineStatus.hide();
+      pipelineLabel.hide();
+      pipelineLabel.setContent('');
       content.show();
       updatePrompt();
       screen.render();