@selesai/code 0.9.14 → 0.10.0

package/dist/extensions/pi-powerline-footer/tests/editor-performance.test.ts

@@ -1,43 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EditorPerfProfiler, readEditorPerfOptions } from "../editor-performance.ts";
-
-test("editor profiling and A/B switches are opt-in", () => {
-  assert.deepEqual(readEditorPerfOptions({}), {
-    enabled: false,
-    fastRender: true,
-    editorChrome: true,
-    widgets: true,
-    bashWidgets: true,
-    lastPrompt: true,
-  });
-
-  assert.deepEqual(readEditorPerfOptions({
-    POWERLINE_DEBUG_PERF: "1",
-    POWERLINE_PERF_FAST_RENDER: "0",
-    POWERLINE_PERF_EDITOR_CHROME: "0",
-    POWERLINE_PERF_WIDGETS: "0",
-    POWERLINE_PERF_BASH_WIDGETS: "0",
-    POWERLINE_PERF_LAST_PROMPT: "0",
-  }), {
-    enabled: true,
-    fastRender: false,
-    editorChrome: false,
-    widgets: false,
-    bashWidgets: false,
-    lastPrompt: false,
-  });
-});
-
-test("editor profiler reports timings, counts, and draft size", () => {
-  const profiler = new EditorPerfProfiler(readEditorPerfOptions({ POWERLINE_DEBUG_PERF: "1" }));
-
-  profiler.measure("input.total", () => 42);
-  profiler.count("editor.render.fast-hit");
-  profiler.observeDraft(["hello", "world"]);
-
-  const report = profiler.report();
-  assert.match(report, /inputs=1, editor-renders=0, renders\/input=0\.00, max-draft=11/);
-  assert.match(report, /editor\.render\.fast-hit: n=1/);
-  assert.match(report, /input\.total: n=1, avg=/);
-});

package/dist/extensions/pi-powerline-footer/tests/editor-responsiveness.test.ts

@@ -1,136 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createRenderScheduler } from "../render-scheduler.ts";
-
-test("render scheduler coalesces pending status renders", () => {
-  const originalSetTimeout = globalThis.setTimeout;
-  const callbacks: Array<() => void> = [];
-  const delays: number[] = [];
-  let renderCount = 0;
-
-  globalThis.setTimeout = ((callback: () => void, delay?: number) => {
-    callbacks.push(callback);
-    delays.push(delay ?? 0);
-    return { id: callbacks.length } as ReturnType<typeof setTimeout>;
-  }) as typeof setTimeout;
-
-  try {
-    const scheduler = createRenderScheduler(() => { renderCount += 1; }, 33);
-
-    scheduler.schedule();
-    scheduler.schedule(150);
-    scheduler.schedule();
-
-    assert.equal(callbacks.length, 1);
-    assert.equal(delays[0], 33);
-    callbacks[0]?.();
-    assert.equal(renderCount, 1);
-
-    scheduler.schedule(150);
-    assert.equal(callbacks.length, 2);
-    assert.equal(delays[1], 150);
-  } finally {
-    globalThis.setTimeout = originalSetTimeout;
-  }
-});
-
-test("render scheduler pulls pending work forward for an earlier deadline", () => {
-  const originalSetTimeout = globalThis.setTimeout;
-  const originalClearTimeout = globalThis.clearTimeout;
-  const callbacks: Array<() => void> = [];
-  const delays: number[] = [];
-  const cleared = new Set<object>();
-  let renderCount = 0;
-
-  globalThis.setTimeout = ((callback: () => void, delay?: number) => {
-    const handle = { id: callbacks.length + 1 };
-    callbacks.push(callback);
-    delays.push(delay ?? 0);
-    return handle as ReturnType<typeof setTimeout>;
-  }) as typeof setTimeout;
-  globalThis.clearTimeout = ((handle?: ReturnType<typeof setTimeout>) => {
-    if (handle && typeof handle === "object") cleared.add(handle);
-  }) as typeof clearTimeout;
-
-  try {
-    const scheduler = createRenderScheduler(() => { renderCount += 1; }, 33);
-
-    scheduler.schedule(250);
-    scheduler.schedule(33);
-
-    assert.deepEqual(delays, [250, 33]);
-    assert.equal(cleared.size, 1);
-    callbacks[1]?.();
-    assert.equal(renderCount, 1);
-  } finally {
-    globalThis.setTimeout = originalSetTimeout;
-    globalThis.clearTimeout = originalClearTimeout;
-  }
-});
-
-test("render scheduler allows callbacks to schedule follow-up renders", () => {
-  const originalSetTimeout = globalThis.setTimeout;
-  const callbacks: Array<() => void> = [];
-  const delays: number[] = [];
-  let renderCount = 0;
-  let scheduler: ReturnType<typeof createRenderScheduler>;
-
-  globalThis.setTimeout = ((callback: () => void, delay?: number) => {
-    callbacks.push(callback);
-    delays.push(delay ?? 0);
-    return { id: callbacks.length } as ReturnType<typeof setTimeout>;
-  }) as typeof setTimeout;
-
-  try {
-    scheduler = createRenderScheduler(() => {
-      renderCount += 1;
-      if (renderCount === 1) {
-        scheduler.schedule(150);
-      }
-    }, 33);
-
-    scheduler.schedule();
-    callbacks[0]?.();
-
-    assert.equal(renderCount, 1);
-    assert.equal(callbacks.length, 2);
-    assert.equal(delays[1], 150);
-
-    callbacks[1]?.();
-    assert.equal(renderCount, 2);
-  } finally {
-    globalThis.setTimeout = originalSetTimeout;
-  }
-});
-
-test("render scheduler cancels pending status renders", () => {
-  const originalSetTimeout = globalThis.setTimeout;
-  const originalClearTimeout = globalThis.clearTimeout;
-  const callbacks: Array<() => void> = [];
-  const cleared = new Set<object>();
-  let renderCount = 0;
-
-  globalThis.setTimeout = ((callback: () => void) => {
-    const handle = { id: callbacks.length + 1 };
-    callbacks.push(callback);
-    return handle as ReturnType<typeof setTimeout>;
-  }) as typeof setTimeout;
-  globalThis.clearTimeout = ((handle?: ReturnType<typeof setTimeout>) => {
-    if (handle && typeof handle === "object") {
-      cleared.add(handle);
-    }
-  }) as typeof clearTimeout;
-
-  try {
-    const scheduler = createRenderScheduler(() => { renderCount += 1; }, 33);
-
-    scheduler.schedule();
-    scheduler.cancel();
-
-    assert.equal(cleared.size, 1);
-    assert.equal(renderCount, 0);
-  } finally {
-    globalThis.setTimeout = originalSetTimeout;
-    globalThis.clearTimeout = originalClearTimeout;
-  }
-});

package/dist/extensions/pi-powerline-footer/tests/fixed-editor-border.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { initTheme, theme } from "../../../modes/interactive/theme/theme.ts";
-
-/**
- * The powerline editor render draws its own border. It must respect the
- * editor's `borderColor` (set by interactive-mode to the bash-mode / thinking
- * color) instead of always using the gray "sep" color, so typing `!` visibly
- * switches the input field to bash mode.
- */
-function powerlineBorderColor(editor: { borderColor: unknown }, s: string): string {
-  return typeof editor.borderColor === "function"
-    ? (editor.borderColor as (str: string) => string)(s)
-    : `\x1b[38;5;244m${s}\x1b[0m`;
-}
-
-describe("powerline editor border respects editor.borderColor", () => {
-  it("uses the bash-mode color when interactive-mode sets it (typing !)", () => {
-    initTheme("dark");
-    const editorWithBashBorder = {
-      borderColor: theme.getBashModeBorderColor(),
-    };
-    const border = powerlineBorderColor(editorWithBashBorder, "─".repeat(5));
-    // Bash mode is green in the theme; the border must carry a color code.
-    expect(border).toContain("\x1b[");
-    expect(border).toMatch(/[0-9]+;[0-9]+;[0-9]+m/);
-    // And it must NOT be the plain gray "sep" code.
-    expect(border).not.toContain("\x1b[38;5;244m");
-  });
-
-  it("falls back to the gray sep color when borderColor is not a function", () => {
-    const border = powerlineBorderColor({ borderColor: "x" }, "─".repeat(5));
-    expect(border).toBe("\x1b[38;5;244m─────\x1b[0m");
-  });
-});
-
-function getBashModeBorderColor(): (str: string) => string {
-  // Mirrors theme.getBashModeBorderColor(): colors with the theme's "bashMode" color.
-  return (str: string) => `\x1b[38;5;34m${str}\x1b[39m`;
-}

package/dist/extensions/pi-powerline-footer/tests/git-optional-locks.test.ts

@@ -1,64 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { readOnlyGitEnv } from "../git-status.ts";
-
-const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
-
-// Background fetches spawn git with up to 500ms timeouts; give them room.
-const FETCH_SETTLE_MS = 1200;
-
-test("read-only git commands opt out of git's optional index lock", () => {
-  const env = readOnlyGitEnv({ PATH: "/usr/bin" });
-  assert.equal(env.GIT_OPTIONAL_LOCKS, "0");
-  assert.equal(env.PATH, "/usr/bin", "must extend the ambient environment, not replace it");
-});
-
-test("readOnlyGitEnv overrides an inherited GIT_OPTIONAL_LOCKS=1", () => {
-  assert.equal(readOnlyGitEnv({ GIT_OPTIONAL_LOCKS: "1" }).GIT_OPTIONAL_LOCKS, "0");
-});
-
-// Guards the regression end to end, via a `git` shim on PATH: the footer polls
-// every repo the user visits, so it must never take `.git/index.lock`.
-test("the git process the footer spawns receives GIT_OPTIONAL_LOCKS=0", { skip: process.platform === "win32" ? "POSIX shim" : false }, async () => {
-  const dir = mkdtempSync(join(tmpdir(), "powerline-git-locks-"));
-  const bin = join(dir, "bin");
-  mkdirSync(bin);
-  const log = join(dir, "calls.log");
-
-  writeFileSync(
-    join(bin, "git"),
-    `#!/bin/sh\necho "GIT_OPTIONAL_LOCKS=\${GIT_OPTIONAL_LOCKS-unset} ARGS=$*" >> ${JSON.stringify(log)}\nexit 0\n`,
-    { mode: 0o755 },
-  );
-
-  const originalPath = process.env.PATH;
-  const originalOptionalLocks = process.env.GIT_OPTIONAL_LOCKS;
-  process.env.PATH = `${bin}:${originalPath ?? ""}`;
-  // Some environments export GIT_OPTIONAL_LOCKS=0 as a machine-wide workaround
-  // for this bug; force the opposite so we can't inherit a false pass.
-  process.env.GIT_OPTIONAL_LOCKS = "1";
-  try {
-    // Imported here so the module reads the shimmed PATH when it spawns.
-    const { getGitStatus, invalidateGitStatus, invalidateGitBranch } = await import("../git-status.ts");
-    invalidateGitStatus();
-    invalidateGitBranch();
-    getGitStatus("main");
-    await sleep(FETCH_SETTLE_MS);
-  } finally {
-    process.env.PATH = originalPath;
-    if (originalOptionalLocks === undefined) delete process.env.GIT_OPTIONAL_LOCKS;
-    else process.env.GIT_OPTIONAL_LOCKS = originalOptionalLocks;
-  }
-
-  assert.ok(existsSync(log), "expected the footer to spawn git");
-  const calls = readFileSync(log, "utf8").trim().split("\n");
-  const status = calls.filter((line) => line.includes("ARGS=status --porcelain"));
-  assert.ok(status.length > 0, `expected a status call, got:\n${calls.join("\n")}`);
-  for (const call of calls) {
-    assert.match(call, /GIT_OPTIONAL_LOCKS=0/, `git spawned without the lock opt-out: ${call}`);
-  }
-});

package/dist/extensions/pi-powerline-footer/tests/git-status.test.ts

@@ -1,92 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { detectGitHost, getCurrentBranch, getGitStatus, invalidateGitBranch, invalidateGitStatus, subscribeGitUpdates } from "../git-status.ts";
-
-const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
-
-// Background fetches spawn git with up to 500ms timeouts; give them room.
-const FETCH_SETTLE_MS = 1200;
-
-test("git status supports disabling extension git polling", () => {
-  assert.deepEqual(getGitStatus("main", "off"), {
-    branch: "main",
-    staged: 0,
-    unstaged: 0,
-    untracked: 0,
-  });
-});
-
-test("invalidateGitStatus serves stale counts while refreshing (no flicker to zeros)", async () => {
-  getGitStatus("provider-branch"); // kick off the initial background fetch
-  await sleep(FETCH_SETTLE_MS);
-
-  const seeded = getGitStatus("provider-branch");
-
-  invalidateGitStatus();
-  const afterInvalidate = getGitStatus("provider-branch");
-  assert.deepEqual(
-    { staged: afterInvalidate.staged, unstaged: afterInvalidate.unstaged, untracked: afterInvalidate.untracked },
-    { staged: seeded.staged, unstaged: seeded.unstaged, untracked: seeded.untracked },
-  );
-
-  // The background refresh converges to real data again (repo is unchanged).
-  await sleep(FETCH_SETTLE_MS);
-  const refreshed = getGitStatus("provider-branch");
-  assert.deepEqual(
-    { staged: refreshed.staged, unstaged: refreshed.unstaged, untracked: refreshed.untracked },
-    { staged: seeded.staged, unstaged: seeded.unstaged, untracked: seeded.untracked },
-  );
-});
-
-test("invalidateGitBranch keeps serving the last known branch while refreshing", async () => {
-  getGitStatus("provider-fallback"); // seed branch cache
-  await sleep(FETCH_SETTLE_MS);
-
-  const realBranch = getCurrentBranch("provider-fallback");
-  // Once fetched, the cached branch no longer falls back to the provider
-  // (null in non-git directories, the actual branch name inside a repo).
-  assert.notEqual(realBranch, "provider-fallback");
-
-  invalidateGitBranch();
-  assert.equal(getCurrentBranch("provider-fallback"), realBranch);
-});
-
-test("git cache completion notifies active footer subscribers", async () => {
-  let updates = 0;
-  const unsubscribe = subscribeGitUpdates(() => { updates += 1; });
-  try {
-    invalidateGitStatus();
-    invalidateGitBranch();
-    getGitStatus("provider-fallback");
-    await sleep(FETCH_SETTLE_MS);
-    assert.ok(updates > 0);
-  } finally {
-    unsubscribe();
-  }
-});
-
-test("detectGitHost recognizes known hosts over SSH and HTTPS", () => {
-  assert.equal(detectGitHost("git@github.com:owner/repo.git"), "github");
-  assert.equal(detectGitHost("https://github.com/owner/repo.git"), "github");
-  assert.equal(detectGitHost("ssh://git@gitlab.com/owner/repo.git"), "gitlab");
-  assert.equal(detectGitHost("https://gitlab.com/owner/repo"), "gitlab");
-  assert.equal(detectGitHost("git@bitbucket.org:owner/repo.git"), "bitbucket");
-  assert.equal(detectGitHost("https://user@bitbucket.org/owner/repo.git"), "bitbucket");
-});
-
-test("detectGitHost normalizes www and sub-domains", () => {
-  assert.equal(detectGitHost("https://www.github.com/owner/repo"), "github");
-  assert.equal(detectGitHost("git@ssh.github.com:owner/repo.git"), "github");
-});
-
-test("detectGitHost treats unknown or self-hosted remotes as a generic host", () => {
-  assert.equal(detectGitHost("git@git.example.com:owner/repo.git"), "other");
-  assert.equal(detectGitHost("https://gitea.mycorp.dev/owner/repo.git"), "other");
-  assert.equal(detectGitHost("/srv/git/local.git"), "other");
-});
-
-test("detectGitHost returns null when there is no remote", () => {
-  assert.equal(detectGitHost(null), null);
-  assert.equal(detectGitHost(""), null);
-  assert.equal(detectGitHost("   "), null);
-});

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

@@ -1,129 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  GUIDE_COMPACT_LINES,
-  GUIDE_DISMISS_HINT,
-  GUIDE_FEATURES,
-  getGuideFeatureLines,
-  getGuidePreferences,
-  getNewGuideFeatures,
-  markGuideVersionSeen,
-  resolveGuideDisplayMode,
-  saveGuidePreferences,
-  type GuideFeature,
-} from "../guide.ts";
-
-const features: GuideFeature[] = [
-  { id: "old", title: "Old", example: "/old", introducedIn: "0.5.0" },
-  { id: "new", title: "New", example: "/new", introducedIn: "0.5.3" },
-  { id: "future", title: "Future", example: "/future", introducedIn: "0.6.0" },
-];
-
-
-test("explicit full guide opens for each real session start", () => {
-  for (const reason of ["startup", "new", "resume", "fork"]) {
-    assert.equal(resolveGuideDisplayMode({ reason, hasUI: true, guideMode: "full" }), "full");
-  }
-});
-
-test("guide dismissal and compact preferences change automatic display", () => {
-  assert.equal(resolveGuideDisplayMode({ reason: "startup", hasUI: true, guideMode: "compact" }), "compact");
-  assert.equal(resolveGuideDisplayMode({ reason: "startup", hasUI: true, guideMode: "off" }), "none");
-  assert.equal(resolveGuideDisplayMode({ reason: "reload", hasUI: true, guideMode: "full" }), "none");
-  assert.equal(resolveGuideDisplayMode({ reason: "startup", hasUI: false, guideMode: "full" }), "none");
-});
-
-test("guide defaults to a compact header so the native dock stays uncluttered", () => {
-  const preferences = getGuidePreferences({});
-  assert.equal(preferences.mode, "compact");
-  assert.equal(resolveGuideDisplayMode({ reason: "startup", hasUI: true, guideMode: preferences.mode }), "compact");
-});
-
-test("full and compact guide content expose README commands and examples", () => {
-  const full = getGuideFeatureLines()
-    .map((line) => line.kind === "section" ? line.text : `${line.feature.title}: ${line.feature.example}`)
-    .join("\n");
-  const compact = GUIDE_COMPACT_LINES.join("\n");
-
-  assert.match(full, /\/settings/);
-  assert.match(full, /\$workflow/);
-  assert.match(full, /Ask the architect to challenge this plan/);
-  assert.match(full, /Ask the researcher to research <topic> and cite sources/);
-  assert.match(full, /\/skill:\*/);
-  assert.match(full, /\/handoff-new Next: fix <problem>; start with a coding plan/);
-  assert.doesNotMatch(full, /question\(|\/intercom|powerline/);
-  assert.match(compact, /\/settings/);
-  assert.match(compact, /\$workflow/);
-  assert.match(compact, /Ask the researcher to research <topic>/);
-});
-
-test("blocking guide dismisses only from its overlay input handler", () => {
-  const source = readFileSync(new URL("../index.ts", import.meta.url), "utf8");
-
-  assert.equal(GUIDE_DISMISS_HINT, "Press any key to continue");
-  assert.match(source, /guideOverlayBlocking = true;[\s\S]*handleInput: \(\) => dismiss\(\),/);
-  // The blocking guide cannot be dismissed by the welcome scheduler: dismissWelcome
-  // bails while guideOverlayBlocking is set, so only the overlay's input handler
-  // (which clears the flag first) can close it.
-  assert.match(source, /function dismissWelcome\(ctx: any\) \{[\s\S]*?if \(guideOverlayBlocking\) return;/);
-});
-
-test("README-derived guide entries stay in the feature map", () => {
-  assert.deepEqual(
-    GUIDE_FEATURES.filter((feature) => feature.id === "settings" || feature.id === "handoff").map((feature) => feature.example),
-    ["/settings · /guide compact|off|reset · /reload", "/handoff-new Next: fix <problem>; start with a coding plan."],
-  );
-});
-
-test("new feature detection is version bounded and empty on first install", () => {
-  assert.deepEqual(getNewGuideFeatures(undefined, "0.5.3", features), []);
-  assert.deepEqual(getNewGuideFeatures("0.5.0", "0.5.3", features).map((feature) => feature.id), ["new"]);
-  assert.deepEqual(getNewGuideFeatures("0.5.3", "0.5.3", features), []);
-  assert.deepEqual(getNewGuideFeatures("0.5.0", "0.5.2", features), []);
-});
-
-test("guide dismissal persists only the mode and version marker", () => {
-  const dir = mkdtempSync(join(tmpdir(), "selesai-guide-"));
-  const settingsPath = join(dir, "settings.json");
-
-  try {
-    assert.equal(saveGuidePreferences({ mode: "off", lastSeenVersion: "0.5.3" }, settingsPath), true);
-    const settings = JSON.parse(readFileSync(settingsPath, "utf8")) as Record<string, unknown>;
-    assert.deepEqual(settings.selesaiGuide, { mode: "off", lastSeenVersion: "0.5.3" });
-    assert.equal(getGuidePreferences(settings).mode, "off");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("version marking never persists an implicit guide mode", () => {
-  const dir = mkdtempSync(join(tmpdir(), "selesai-guide-"));
-  const settingsPath = join(dir, "settings.json");
-
-  try {
-    // markGuideVersionSeen writes only the version marker; the mode stays
-    // unset so the default (compact) applies instead of being locked in.
-    assert.equal(markGuideVersionSeen("0.5.3", settingsPath), true);
-    const settings = JSON.parse(readFileSync(settingsPath, "utf8")) as Record<string, unknown>;
-    assert.deepEqual(settings.selesaiGuide, { lastSeenVersion: "0.5.3" });
-    assert.equal(getGuidePreferences(settings).mode, "compact");
-
-    // An explicitly chosen mode is preserved across version-only writes.
-    assert.equal(saveGuidePreferences({ mode: "off" }, settingsPath), true);
-    assert.equal(saveGuidePreferences({ lastSeenVersion: "0.6.0" }, settingsPath), true);
-    const after = JSON.parse(readFileSync(settingsPath, "utf8")) as Record<string, unknown>;
-    assert.deepEqual(after.selesaiGuide, { mode: "off", lastSeenVersion: "0.6.0" });
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("invalid persisted guide settings fall back to the compact guide", () => {
-  assert.deepEqual(getGuidePreferences({ selesaiGuide: { mode: "unexpected", lastSeenVersion: 42 } }), {
-    mode: "compact",
-    lastSeenVersion: undefined,
-  });
-});

package/dist/extensions/pi-powerline-footer/tests/jump-shortcuts.test.ts

@@ -1,116 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { CURSOR_MARKER } from "@earendil-works/pi-tui";
-import { isSupportedSuperShortcut, matchesConfiguredShortcut, shortcutConflictKey } from "../shortcuts.ts";
-import { parseBashModeSettings, renderFastPowerlineEditor, resolveShortcutConfig } from "../index.ts";
-
-test("surviving editor shortcuts resolve without app-owned chat scrolling", () => {
-  const resolved = resolveShortcutConfig({});
-  assert.equal(resolved.stashHistory, "ctrl+alt+h");
-  assert.equal(resolved.copyEditor, "ctrl+alt+c");
-  assert.equal(resolved.cutEditor, "ctrl+alt+x");
-  assert.equal(resolved.editorStart, "super+shift+up");
-  assert.equal(resolved.editorEnd, "super+shift+down");
-  assert.equal(Object.keys(resolved).some((key) => key.startsWith("scroll")), false);
-  assert.equal(Object.keys(resolved).some((key) => key.startsWith("jump")), false);
-});
-
-test("super shortcut matching and conflict normalization remain supported", () => {
-  assert.equal(matchesConfiguredShortcut("\x1b[1;9A", "super+up"), true);
-  assert.equal(matchesConfiguredShortcut("c", "super+c"), false);
-  assert.equal(isSupportedSuperShortcut("super+up"), true);
-  assert.equal(isSupportedSuperShortcut("super+z"), false);
-  assert.equal(shortcutConflictKey("super+home"), "super+up");
-});
-
-
-test("editor boundary shortcuts remain configurable", () => {
-  const resolved = resolveShortcutConfig({
-    powerlineShortcuts: {
-      editorStart: "ctrl+shift+u",
-      editorEnd: "ctrl+shift+d",
-    },
-  });
-
-  assert.equal(resolved.editorStart, "ctrl+shift+u");
-  assert.equal(resolved.editorEnd, "ctrl+shift+d");
-});
-
-test("bash completions are opt-in", () => {
-  assert.equal(parseBashModeSettings({}).completions, false);
-  assert.equal(parseBashModeSettings({ bashMode: { completions: true } }).completions, true);
-  assert.equal(parseBashModeSettings({ bashMode: { completions: false } }).completions, false);
-});
-
-test("fast editor render keeps Powerline chrome for large drafts", () => {
-  const editor = {
-    focused: true,
-    isShowingAutocomplete: () => false,
-    tui: { terminal: { rows: 24 } },
-  };
-  Reflect.set(editor, "state", {
-    lines: ["intro", "x".repeat(5000)],
-    cursorLine: 1,
-    cursorCol: 5000,
-  });
-
-  const rendered = renderFastPowerlineEditor(editor, 80, {
-    bashModeActive: false,
-    completionsEnabled: false,
-  });
-
-  assert.ok(rendered);
-  assert.ok(rendered[0]?.includes("↑"));
-  assert.ok(rendered.some((line) => line.includes(CURSOR_MARKER)));
-  // Selesai defaults to an empty editor prompt glyph, so no ">" is injected.
-});
-
-test("fast editor render falls back for short drafts and enabled completions", () => {
-  const editor = {
-    focused: true,
-    isShowingAutocomplete: () => false,
-    tui: { terminal: { rows: 24 } },
-  };
-  Reflect.set(editor, "state", { lines: ["short"], cursorLine: 0, cursorCol: 5 });
-
-  assert.equal(renderFastPowerlineEditor(editor, 80, {
-    bashModeActive: false,
-    completionsEnabled: false,
-  }), null);
-
-  Reflect.set(editor, "state", { lines: ["x".repeat(5000)], cursorLine: 0, cursorCol: 5000 });
-  assert.equal(renderFastPowerlineEditor(editor, 80, {
-    bashModeActive: false,
-    completionsEnabled: true,
-  }), null);
-});
-
-test("fast editor render falls back for wide characters", () => {
-  const editor = {
-    focused: true,
-    isShowingAutocomplete: () => false,
-    tui: { terminal: { rows: 24 } },
-  };
-  Reflect.set(editor, "state", { lines: ["漢".repeat(1300)], cursorLine: 0, cursorCol: 1291 });
-
-  assert.equal(renderFastPowerlineEditor(editor, 80, {
-    bashModeActive: false,
-    completionsEnabled: false,
-  }), null);
-});
-
-test("fast editor render updates the editor navigation width", () => {
-  const editor = {
-    focused: true,
-    isShowingAutocomplete: () => false,
-    lastWidth: 12,
-    tui: { terminal: { rows: 24 } },
-  };
-  Reflect.set(editor, "state", { lines: ["x".repeat(5000)], cursorLine: 0, cursorCol: 5000 });
-
-  assert.ok(renderFastPowerlineEditor(editor, 80, {
-    bashModeActive: false,
-    completionsEnabled: false,
-  }));
-  assert.equal(Reflect.get(editor, "lastWidth"), 76);
-});