@selesai/code 0.7.0 → 0.8.1

package/dist/extensions/pi-powerline-footer/segments.ts

@@ -5,6 +5,10 @@ import type { BuiltinStatusLineSegmentId, RenderedSegment, SegmentContext, Seman
 import { normalizeCompactExtensionStatus, normalizeExtensionStatusValue } from "./powerline-config.ts";
 import { fg, rainbow, applyColor } from "./theme.ts";
 import { getIcons, SEP_DOT, getThinkingText } from "./icons.ts";
+import { formatUsdCost } from "./currency-rates.ts";
+import { getGitRemoteHost } from "./git-status.ts";
+import type { IconSet } from "./icons.ts";
+import type { GitHost } from "./git-status.ts";
 
 function color(ctx: SegmentContext, semantic: SemanticColor, text: string): string {
   return fg(ctx.theme, semantic, text, ctx.colors);
@@ -47,8 +51,10 @@ const modelSegment: StatusLineSegment = {
     const opts = ctx.options.model ?? {};
 
     let modelName = ctx.model?.name || ctx.model?.id || "no-model";
-    // Strip "Claude " prefix for brevity
-    if (modelName.startsWith("Claude ")) {
+    if (opts.display === "qualified" && ctx.model?.id) {
+      const provider = ctx.model.provider || ctx.model.providerId || ctx.model.providerName;
+      modelName = provider && !ctx.model.id.includes("/") ? `${provider}/${ctx.model.id}` : ctx.model.id;
+    } else if (modelName.startsWith("Claude ")) {
       modelName = modelName.slice(7);
     }
 
@@ -68,38 +74,6 @@ const modelSegment: StatusLineSegment = {
   },
 };
 
-const identityGroupSegment: StatusLineSegment = {
-  id: "identity_group",
-  render(ctx) {
-    const model = modelSegment.render({
-      ...ctx,
-      options: { ...ctx.options, model: { ...(ctx.options.model ?? {}), showThinkingLevel: false } },
-    });
-
-    const parts = model.visible && model.content ? [model.content] : [];
-    const thinkingText = getThinkingText(ctx.thinkingLevel || "off");
-    if (thinkingText) {
-      const level = ctx.thinkingLevel || "off";
-      let thinkingContent: string;
-      if (level === "high" || level === "xhigh") {
-        thinkingContent = rainbow(thinkingText);
-      } else if (level === "minimal") {
-        thinkingContent = color(ctx, "thinkingMinimal", thinkingText);
-      } else if (level === "low") {
-        thinkingContent = color(ctx, "thinkingLow", thinkingText);
-      } else if (level === "medium") {
-        thinkingContent = color(ctx, "thinkingMedium", thinkingText);
-      } else {
-        thinkingContent = color(ctx, "thinking", thinkingText);
-      }
-      parts.push(thinkingContent);
-    }
-
-    if (parts.length === 0) return { content: "", visible: false };
-    return { content: parts.join(" "), visible: true };
-  },
-};
-
 const shellModeSegment: StatusLineSegment = {
   id: "shell_mode",
   render(ctx) {
@@ -157,14 +131,31 @@ const pathSegment: StatusLineSegment = {
   },
 };
 
+/**
+ * Icon for the branch label: the origin remote's host logo when hostIcon is
+ * enabled and a remote is known, otherwise the plain branch icon. An
+ * unrecognized remote falls back to the generic git logo.
+ */
+function resolveBranchIcon(icons: IconSet, hostIcon: boolean): string {
+  if (!hostIcon) return icons.branch;
+  const host = getGitRemoteHost();
+  const byHost: Record<GitHost, string> = {
+    github: icons.github,
+    gitlab: icons.gitlab,
+    bitbucket: icons.bitbucket,
+    other: icons.git,
+  };
+  return host ? byHost[host] : icons.branch;
+}
+
 const gitSegment: StatusLineSegment = {
   id: "git",
   render(ctx) {
     const icons = getIcons();
     const opts = ctx.options.git ?? {};
     const { branch, staged, unstaged, untracked } = ctx.git;
-    const gitStatus = (staged > 0 || unstaged > 0 || untracked > 0)
-      ? { staged, unstaged, untracked }
+    const gitStatus = (staged > 0 || unstaged > 0 || untracked > 0) 
+      ? { staged, unstaged, untracked } 
       : null;
 
     if (!branch && !gitStatus) return { content: "", visible: false };
@@ -177,7 +168,8 @@ const gitSegment: StatusLineSegment = {
     let content = "";
     if (showBranch && branch) {
       // Color just the branch name (icon + branch text)
-      content = color(ctx, branchColor, withIcon(icons.branch, branch));
+      const branchIcon = resolveBranchIcon(icons, opts.hostIcon === true);
+      content = color(ctx, branchColor, withIcon(branchIcon, branch));
     }
 
     // Add status indicators (each with their own color, not wrapped)
@@ -225,7 +217,7 @@ const thinkingSegment: StatusLineSegment = {
     const label = levelText[level] || level;
     const content = `think:${label}`;
 
-    if (level === "high" || level === "xhigh") {
+    if (level === "high" || level === "xhigh" || level === "max") {
       return { content: rainbow(content), visible: true };
     }
 
@@ -253,6 +245,31 @@ const subagentsSegment: StatusLineSegment = {
   },
 };
 
+const queueSegment: StatusLineSegment = {
+  id: "queue",
+  render(ctx) {
+    const summary = ctx.queueSummary;
+    const parts: string[] = [];
+
+    if (summary.compacting && summary.queueCount > 0) {
+      parts.push(`compact q ${summary.queueCount}`);
+    } else if (summary.queueCount > 0) {
+      parts.push(`q ${summary.queueCount}`);
+    }
+
+    if (summary.ideaCount > 0) {
+      parts.push(`ideas ${summary.ideaCount}`);
+    }
+
+    if (summary.blockedCount > 0) {
+      parts.push(`blocked ${summary.blockedCount}`);
+    }
+
+    if (parts.length === 0) return { content: "", visible: false };
+    return { content: color(ctx, "queue", parts.join(SEP_DOT)), visible: true };
+  },
+};
+
 const tokenInSegment: StatusLineSegment = {
   id: "token_in",
   render(ctx) {
@@ -290,52 +307,32 @@ const tokenTotalSegment: StatusLineSegment = {
   },
 };
 
-const usageGroupSegment: StatusLineSegment = {
-  id: "usage_group",
+const costSegment: StatusLineSegment = {
+  id: "cost",
   render(ctx) {
-    const icons = getIcons();
-    const { input, output, cacheRead, cacheWrite, cost } = ctx.usageStats;
-    const total = input + output + cacheRead + cacheWrite;
+    const cost = ctx.usageStats.cost + (ctx.usageStats.subagentCost ?? 0);
     const usingSubscription = ctx.usingSubscription;
 
-    const parts: string[] = [];
-    if (input || cacheRead) {
-      const inText = input ? withIcon(icons.input, formatTokens(input)) : withIcon(icons.input, "0");
-      const cacheRate = input + cacheRead > 0 ? Math.round((cacheRead / (input + cacheRead)) * 100) : 0;
-      const cacheText = `${formatTokens(cacheRead)}/${cacheRate}%`;
-      parts.push(color(ctx, "tokens", `${inText}(${cacheText})`));
+    if (!cost && !usingSubscription) {
+      return { content: "", visible: false };
     }
 
-    if (output) {
-      parts.push(color(ctx, "tokens", withIcon(icons.output, formatTokens(output))));
+    const reportedCost = cost > 0 ? formatUsdCost(cost, ctx.options.cost?.currency) : null;
+    if (!usingSubscription) {
+      return reportedCost
+        ? { content: color(ctx, "cost", reportedCost), visible: true }
+        : { content: "", visible: false };
     }
 
-    const totalCostParts: string[] = [];
-    if (total) totalCostParts.push(withIcon(icons.tokens, formatTokens(total)));
-    if (cost || usingSubscription) {
-      totalCostParts.push(usingSubscription ? "sub" : `$${cost.toFixed(2)}`);
+    const subscriptionDisplay = ctx.options.cost?.subscriptionDisplay ?? "subscription";
+    if (subscriptionDisplay === "reported-cost" && reportedCost) {
+      return { content: color(ctx, "cost", reportedCost), visible: true };
     }
-    if (totalCostParts.length > 0) {
-      parts.push(color(ctx, "tokens", totalCostParts.join(" ")));
-    }
-
-    if (parts.length === 0) return { content: "", visible: false };
-    return { content: parts.join(SEP_DOT), visible: true };
-  },
-};
-
-const costSegment: StatusLineSegment = {
-  id: "cost",
-  render(ctx) {
-    const { cost } = ctx.usageStats;
-    const usingSubscription = ctx.usingSubscription;
-
-    if (!cost && !usingSubscription) {
-      return { content: "", visible: false };
+    if (subscriptionDisplay === "both" && reportedCost) {
+      return { content: color(ctx, "cost", `${reportedCost} (sub)`), visible: true };
     }
 
-    const costDisplay = usingSubscription ? "(sub)" : `$${cost.toFixed(2)}`;
-    return { content: color(ctx, "cost", costDisplay), visible: true };
+    return { content: color(ctx, "cost", "(sub)"), visible: true };
   },
 };
 
@@ -345,24 +342,33 @@ const contextPctSegment: StatusLineSegment = {
     if (ctx.customCompactionEnabled) return { content: "", visible: false };
 
     const icons = getIcons();
-    const pct = ctx.contextPercent;
-    const window = ctx.contextWindow;
-    const barWidth = 5;
-    const filled = Math.max(0, Math.min(barWidth, Math.round((pct / 100) * barWidth)));
-    const bar = `[${"=".repeat(filled)}${" ".repeat(barWidth - filled)}]`;
-    const pctDisplay = `${Math.round(pct)}%`;
-    const text = `${bar} ${pctDisplay}/${formatTokens(window)}`;
-
-    let semanticColor: "context" | "contextWarn" | "contextError";
-    if (pct >= 70) {
-      semanticColor = "contextError";
-    } else if (pct >= 50) {
-      semanticColor = "contextWarn";
+    const { contextTokens, contextPercent, contextWindow } = ctx;
+
+    const autoIcon = ctx.autoCompactEnabled && icons.auto ? ` ${icons.auto}` : "";
+    const percentOnly = ctx.options.context?.format === "percent";
+    const hasKnownUsage = contextTokens !== null && contextPercent !== null;
+    const approximate = ctx.contextApproximate ? "~" : "";
+    // "full" (default): tokens/window + one-decimal percentage + auto-compact icon.
+    // "percent": bare rounded percentage, threshold-colored, no icons.
+    const text = percentOnly
+      ? (hasKnownUsage ? `${approximate}${Math.round(contextPercent)}%` : "?")
+      : hasKnownUsage
+        ? `${approximate}${formatTokens(contextTokens)}/${formatTokens(contextWindow)} (${contextPercent.toFixed(1)}%)${autoIcon}`
+        : `?/${formatTokens(contextWindow)}${autoIcon}`;
+
+    // Icon outside color, text inside - use semantic colors for thresholds
+    let content: string;
+    const colored = (semantic: "context" | "contextWarn" | "contextError") =>
+      percentOnly ? color(ctx, semantic, text) : withIcon(icons.context, color(ctx, semantic, text));
+    if (hasKnownUsage && contextPercent > 90) {
+      content = colored("contextError");
+    } else if (hasKnownUsage && contextPercent > 70) {
+      content = colored("contextWarn");
     } else {
-      semanticColor = "context";
+      content = colored("context");
     }
 
-    return { content: withIcon(icons.context, color(ctx, semanticColor, text)), visible: true };
+    return { content, visible: true };
   },
 };
 
@@ -429,17 +435,6 @@ const sessionSegment: StatusLineSegment = {
   },
 };
 
-const sessionNameSegment: StatusLineSegment = {
-  id: "session_name",
-  render(ctx) {
-    const icons = getIcons();
-    const display = ctx.sessionName?.trim();
-    if (!display) return { content: "", visible: false };
-
-    return { content: color(ctx, "model", withIcon(icons.session, display)), visible: true };
-  },
-};
-
 const hostnameSegment: StatusLineSegment = {
   id: "hostname",
   render() {
@@ -453,11 +448,21 @@ const cacheReadSegment: StatusLineSegment = {
   id: "cache_read",
   render(ctx) {
     const icons = getIcons();
-    const { cacheRead } = ctx.usageStats;
+    const { cacheRead, input } = ctx.usageStats;
     if (!cacheRead) return { content: "", visible: false };
 
-    const parts = [icons.cache, icons.input, formatTokens(cacheRead)].filter(Boolean);
-    const content = parts.join(" ");
+    const format = ctx.options.cache_read?.format ?? "tokens";
+    const hitRate = input + cacheRead > 0
+      ? ((cacheRead / (input + cacheRead)) * 100).toFixed(0)
+      : "0";
+
+    let content: string;
+    if (format === "percent") {
+      content = [icons.cache, `${hitRate}%`].filter(Boolean).join(" ");
+    } else {
+      const tokens = [icons.cache, icons.input, formatTokens(cacheRead)].filter(Boolean).join(" ");
+      content = format === "both" ? `${tokens} (${hitRate}%)` : tokens;
+    }
     return { content: color(ctx, "tokens", content), visible: true };
   },
 };
@@ -508,23 +513,21 @@ const extensionStatusesSegment: StatusLineSegment = {
 
 export const SEGMENTS: Record<BuiltinStatusLineSegmentId, StatusLineSegment> = {
   model: modelSegment,
-  identity_group: identityGroupSegment,
   shell_mode: shellModeSegment,
   path: pathSegment,
   git: gitSegment,
   thinking: thinkingSegment,
   subagents: subagentsSegment,
+  queue: queueSegment,
   token_in: tokenInSegment,
   token_out: tokenOutSegment,
   token_total: tokenTotalSegment,
-  usage_group: usageGroupSegment,
   cost: costSegment,
   context_pct: contextPctSegment,
   context_total: contextTotalSegment,
   time_spent: timeSpentSegment,
   time: timeSegment,
   session: sessionSegment,
-  session_name: sessionNameSegment,
   hostname: hostnameSegment,
   cache_read: cacheReadSegment,
   cache_write: cacheWriteSegment,
@@ -553,8 +556,12 @@ function renderCustomSegment(id: `custom:${string}`, ctx: SegmentContext): Rende
   return { content, visible: true };
 }
 
+function isCustomSegmentId(id: StatusLineSegmentId): id is `custom:${string}` {
+  return id.startsWith("custom:");
+}
+
 export function renderSegment(id: StatusLineSegmentId, ctx: SegmentContext): RenderedSegment {
-  if (id.startsWith("custom:")) {
+  if (isCustomSegmentId(id)) {
     return renderCustomSegment(id, ctx);
   }
 

package/dist/extensions/pi-powerline-footer/session-usage.ts

@@ -22,7 +22,7 @@ function readUsage(value: unknown): UsageStats | null {
   const { input, output, cacheRead, cacheWrite, cost } = value;
   if (![input, output, cacheRead, cacheWrite, cost].every(finiteNumber)) return null;
 
-  return { input, output, cacheRead, cacheWrite, cost };
+  return { input, output, cacheRead, cacheWrite, cost } as UsageStats;
 }
 
 export function readSubagentToolResultUsage(message: unknown): UsageStats | null {

package/dist/extensions/pi-powerline-footer/shortcuts.ts

@@ -1,4 +1,4 @@
-import { matchesKey } from "@earendil-works/pi-tui";
+import { isKeyRelease, matchesKey, type KeyId } from "@earendil-works/pi-tui";
 
 const SUPER_SHORTCUT_PATTERNS = new Map<string, RegExp>([
   ["super+up", /^\x1b\[(?:1;9(?::[12])?[AH]|574(?:19|23);9(?::[12])?u|7;9(?::[12])?~|27;9;65~)$/],
@@ -37,11 +37,25 @@ export function shortcutConflictKey(shortcut: string): string {
   }
 }
 
-export function matchesConfiguredShortcut(data: string, shortcut: string): boolean {
+export function matchesConfiguredShortcut(data: string, shortcut: string | null | undefined): boolean {
+  if (!shortcut) return false;
+
   const normalizedShortcut = shortcut.toLowerCase();
   if (shortcutUsesSuper(normalizedShortcut)) {
     return SUPER_SHORTCUT_PATTERNS.get(normalizedShortcut)?.test(data) ?? false;
   }
 
-  return matchesKey(data, shortcut);
+  return matchesKey(data, shortcut as KeyId);
+}
+
+export function matchesStashShortcutInput(data: string, options: { includePrintableSharpS?: boolean } = {}): boolean {
+  if (isKeyRelease(data)) return false;
+
+  return (options.includePrintableSharpS === true && data === "ß")
+    || data === "\x1bs"
+    || data === "\x1bS"
+    || /^\x1b\[(?:83|115)(?::\d*)?(?::\d*)?;3(?::\d+)?u$/.test(data)
+    || data === "\x1b[27;3;115~"
+    || data === "\x1b[27;3;83~"
+    || matchesKey(data, "alt+s");
 }

package/dist/extensions/pi-powerline-footer/tests/bash-mode.test.ts

@@ -13,6 +13,7 @@ import {
   OneOffBashAutocompleteProvider,
 } from "../bash-mode/completion.ts";
 import { getIcons } from "../icons.ts";
+import { resolveColor } from "../theme.ts";
 import { ManagedShellSession } from "../bash-mode/shell-session.ts";
 
 function getMethod(target: object, name: string): Function {
@@ -23,6 +24,13 @@ function getMethod(target: object, name: string): Function {
   return method;
 }
 
+function resolveManagedShellPath(): string | null {
+  for (const shellPath of ["/bin/zsh", "/bin/bash"]) {
+    if (existsSync(shellPath)) return shellPath;
+  }
+  return null;
+}
+
 function ensureEditorModuleLinks(): { cleanup: () => void } {
   const nodeModulesDir = join(process.cwd(), "node_modules", "@earendil-works");
   mkdirSync(nodeModulesDir, { recursive: true });
@@ -76,6 +84,38 @@ test("project history is stored newest-first and global zsh history parses histf
   assert.deepEqual(global, ["plain-command", "git pull", "git fetch"]);
 });
 
+test("global history caches an unreadable file until its fingerprint changes", () => {
+  const cwd = mkdtempSync(join(tmpdir(), "powerline-unreadable-history-"));
+  const historyPath = join(cwd, ".zsh_history");
+  const originalHistfile = process.env.HISTFILE;
+  const originalDebug = console.debug;
+  let debugCalls = 0;
+
+  try {
+    mkdirSync(historyPath);
+    process.env.HISTFILE = historyPath;
+    console.debug = () => {
+      debugCalls += 1;
+    };
+
+    assert.deepEqual(readGlobalShellHistory("/bin/zsh"), []);
+    assert.deepEqual(readGlobalShellHistory("/bin/zsh"), []);
+    assert.equal(debugCalls, 1);
+
+    rmSync(historyPath, { recursive: true });
+    writeFileSync(historyPath, ": 1711111111:0;git status\n");
+    assert.deepEqual(readGlobalShellHistory("/bin/zsh"), ["git status"]);
+  } finally {
+    console.debug = originalDebug;
+    if (originalHistfile === undefined) {
+      delete process.env.HISTFILE;
+    } else {
+      process.env.HISTFILE = originalHistfile;
+    }
+    rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
 test("matchHistoryEntries returns newest entries when the prefix is empty", () => {
   const matches = matchHistoryEntries([
     "git stash",
@@ -115,6 +155,28 @@ test("theme.json can override icons without touching colors", () => {
   }
 });
 
+test("theme.json loads from the documented agent extension path", () => {
+  const originalAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+  const agentDir = mkdtempSync(join(tmpdir(), "powerline-theme-"));
+
+  try {
+    const themeDir = join(agentDir, "extensions", "powerline-footer");
+    mkdirSync(themeDir, { recursive: true });
+    writeFileSync(join(themeDir, "theme.json"), JSON.stringify({ colors: { model: "#ff5500", path: "#ff5500" } }));
+    process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+
+    assert.equal(resolveColor("model"), "#ff5500");
+    assert.equal(resolveColor("path"), "#ff5500");
+  } finally {
+    if (originalAgentDir === undefined) {
+      delete process.env.SELESAI_CODING_AGENT_DIR;
+    } else {
+      process.env.SELESAI_CODING_AGENT_DIR = originalAgentDir;
+    }
+    rmSync(agentDir, { recursive: true, force: true });
+  }
+});
+
 test("one-off bash command context strips ! and !! prefixes", () => {
   assert.deepEqual(getOneOffBashCommandContext("!git status"), {
     prefix: "!",
@@ -450,12 +512,18 @@ test("deterministic path completion handles bash argument position", async () =>
   assert.equal(suggestion?.source, "path");
 });
 
-test("managed shell session preserves cwd changes across commands", async () => {
+test("managed shell session preserves cwd changes across commands", async (t) => {
+  const shellPath = resolveManagedShellPath();
+  if (!shellPath) {
+    t.skip("requires zsh or bash");
+    return;
+  }
+
   const cwd = mkdtempSync(join(tmpdir(), "powerline-shell-"));
   const childDir = join(cwd, "child");
   mkdirSync(childDir, { recursive: true });
   const store = new BashTranscriptStore({ transcriptMaxLines: 100, transcriptMaxBytes: 64 * 1024 });
-  const session = new ManagedShellSession("/bin/zsh", cwd, store, () => {}, () => {});
+  const session = new ManagedShellSession(shellPath, cwd, store, () => {}, () => {});
 
   try {
     await session.ensureReady();
@@ -482,10 +550,16 @@ test("managed shell session preserves cwd changes across commands", async () =>
   }
 });
 
-test("managed shell session recovers cleanly after interrupt", async () => {
+test("managed shell session recovers cleanly after interrupt", async (t) => {
+  const shellPath = resolveManagedShellPath();
+  if (!shellPath) {
+    t.skip("requires zsh or bash");
+    return;
+  }
+
   const cwd = mkdtempSync(join(tmpdir(), "powerline-shell-interrupt-"));
   const store = new BashTranscriptStore({ transcriptMaxLines: 100, transcriptMaxBytes: 64 * 1024 });
-  const session = new ManagedShellSession("/bin/zsh", cwd, store, () => {}, () => {});
+  const session = new ManagedShellSession(shellPath, cwd, store, () => {}, () => {});
 
   const waitForCommand = async () => {
     const start = Date.now();
@@ -661,7 +735,12 @@ test("bash editor refreshes shell ghost state after a bracketed paste completes"
   }
 });
 
-test("bash editor inserts Finder file drops as path strings", async () => {
+test("bash editor inserts Finder file drops as path strings", async (t) => {
+  if (process.platform === "win32") {
+    t.skip("Finder file drops are macOS/POSIX paths");
+    return;
+  }
+
   const links = ensureEditorModuleLinks();
 
   try {
@@ -733,28 +812,26 @@ test("one-off bash autocomplete provider stays inactive even inside bang command
   assert.equal(suggestions, null);
 });
 
-test("bash autocomplete providers return null synchronously in shell contexts", () => {
+test("bash autocomplete providers return null in shell contexts", async () => {
   const signal = new AbortController().signal;
 
-  const bashSuggestions = new BashAutocompleteProvider().getSuggestions(["git st"], 0, 6, { signal });
-  const oneOffSuggestions = new OneOffBashAutocompleteProvider().getSuggestions(["!git st"], 0, 7, { signal });
+  const bashSuggestions = await new BashAutocompleteProvider().getSuggestions(["git st"], 0, 6, { signal });
+  const oneOffSuggestions = await new OneOffBashAutocompleteProvider().getSuggestions(["!git st"], 0, 7, { signal });
 
   assert.equal(bashSuggestions, null);
   assert.equal(oneOffSuggestions, null);
-  assert.equal(bashSuggestions instanceof Promise, false);
-  assert.equal(oneOffSuggestions instanceof Promise, false);
 });
 
-test("mode-aware autocomplete provider preserves synchronous default results", () => {
+test("mode-aware autocomplete provider preserves default results", async () => {
   const signal = new AbortController().signal;
-  const syncResult = {
+  const result = {
     items: [{ value: "status", label: "status" }],
     prefix: "st",
   };
   const provider = new ModeAwareAutocompleteProvider(
     {
-      getSuggestions() {
-        return syncResult;
+      async getSuggestions() {
+        return result;
       },
       applyCompletion(lines: string[], cursorLine: number, cursorCol: number) {
         return { lines, cursorLine, cursorCol };
@@ -765,10 +842,9 @@ test("mode-aware autocomplete provider preserves synchronous default results", (
     () => false,
   );
 
-  const suggestions = provider.getSuggestions(["st"], 0, 2, { signal });
+  const suggestions = await provider.getSuggestions(["st"], 0, 2, { signal });
 
-  assert.equal(suggestions, syncResult);
-  assert.equal(suggestions instanceof Promise, false);
+  assert.equal(suggestions, result);
 });
 
 test("one-off bash autocomplete provider stays inactive before the bang command starts", async () => {
@@ -876,6 +952,102 @@ test("bash editor shell history state does not clobber the base prompt history i
   }
 });
 
+test("bash editor recalls prompt history from single-line end without losing the live draft", async () => {
+  const links = ensureEditorModuleLinks();
+
+  try {
+    const { BashModeEditor } = await import("../bash-mode/editor.ts");
+    const { KeybindingsManager } = await import(new URL("../node_modules/@selesai/code/dist/core/keybindings.js", import.meta.url).href);
+    const keybindings = KeybindingsManager.create();
+    const createEditor = () => new BashModeEditor(
+      { requestRender() {}, terminal: { columns: 80, rows: 24 } },
+      {},
+      keybindings,
+      {
+        keybindings,
+        isBashModeActive: () => false,
+        isShellRunning: () => false,
+        onExitBashMode() {},
+        onSubmitCommand() {},
+        onInterrupt() {},
+        onNotify() {},
+        getHistoryEntries: () => [],
+        resolveGhostSuggestion: async () => null,
+      },
+    );
+
+    const editor = createEditor();
+    editor.addToHistory("older prompt");
+    editor.addToHistory("previous prompt");
+    editor.setText("draft");
+
+    editor.handleInput("\x1b[A");
+    assert.equal(editor.getText(), "previous prompt");
+
+    editor.handleInput("\x1b[A");
+    assert.equal(editor.getText(), "older prompt");
+
+    editor.handleInput("\x1b[B");
+    assert.equal(editor.getText(), "previous prompt");
+
+    editor.handleInput("\x1b[B");
+    assert.equal(editor.getText(), "draft");
+
+    const midLineEditor = createEditor();
+    midLineEditor.addToHistory("previous prompt");
+    midLineEditor.setText("draft");
+    midLineEditor.handleInput("\x1b[D");
+    midLineEditor.handleInput("\x1b[A");
+
+    assert.equal(midLineEditor.getText(), "draft");
+
+    const multilineEditor = createEditor();
+    multilineEditor.addToHistory("previous prompt");
+    multilineEditor.setText("first line\nsecond line");
+    multilineEditor.handleInput("\x1b[A");
+
+    assert.equal(multilineEditor.getText(), "first line\nsecond line");
+    assert.equal(Reflect.get(multilineEditor, "historyIndex"), -1);
+
+    const firstLineEditor = createEditor();
+    firstLineEditor.addToHistory("previous prompt");
+    firstLineEditor.setText("first line\nsecond line");
+    Reflect.set(Reflect.get(firstLineEditor, "state"), "cursorLine", 0);
+    Reflect.set(Reflect.get(firstLineEditor, "state"), "cursorCol", 0);
+    firstLineEditor.handleInput("\x1b[A");
+
+    assert.equal(firstLineEditor.getText(), "previous prompt");
+
+    const customKeybindings = new KeybindingsManager({
+      "tui.editor.cursorUp": ["up", "alt+k"],
+    });
+    const customBindingEditor = new BashModeEditor(
+      { requestRender() {}, terminal: { columns: 80, rows: 24 } },
+      {},
+      customKeybindings,
+      {
+        keybindings: customKeybindings,
+        isBashModeActive: () => false,
+        isShellRunning: () => false,
+        onExitBashMode() {},
+        onSubmitCommand() {},
+        onInterrupt() {},
+        onNotify() {},
+        getHistoryEntries: () => [],
+        resolveGhostSuggestion: async () => null,
+      },
+    );
+    customBindingEditor.addToHistory("previous prompt");
+    customBindingEditor.setText("draft");
+    customBindingEditor.handleInput("\x1bk");
+
+    assert.equal(customBindingEditor.getText(), "draft");
+    assert.equal(Reflect.get(customBindingEditor, "historyIndex"), -1);
+  } finally {
+    links.cleanup();
+  }
+});
+
 test("bash editor escape exits bash mode", async () => {
   const links = ensureEditorModuleLinks();