@selesai/code 0.7.0 → 0.8.0

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

@@ -0,0 +1,144 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, writeFileSync, mkdtempSync, readFileSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { SessionManager } from "@selesai/code";
+import { getCdArgumentCompletions, resolveCdTarget, runCdCommand } from "../cd-command.ts";
+
+const cdCommandSource = readFileSync(new URL("../cd-command.ts", import.meta.url), "utf-8");
+const indexSource = readFileSync(new URL("../index.ts", import.meta.url), "utf-8");
+
+test("resolveCdTarget supports current, relative, home, and invalid directories", () => {
+  const root = mkdtempSync(join(tmpdir(), "powerline-cd-root-"));
+  const home = mkdtempSync(join(tmpdir(), "powerline-cd-home-"));
+  const child = join(root, "child");
+  const homeProject = join(home, "project");
+  mkdirSync(child);
+  mkdirSync(homeProject);
+  writeFileSync(join(root, "file.txt"), "not a directory");
+
+  assert.equal(resolveCdTarget("", root, home), null);
+  assert.deepEqual(resolveCdTarget("child", root, home), { path: child });
+  assert.deepEqual(resolveCdTarget("~/project", root, home), { path: homeProject });
+  assert.deepEqual(resolveCdTarget("My\\ Folder", root, home), { error: `Directory does not exist: ${join(root, "My Folder")}` });
+  assert.match(resolveCdTarget("missing", root, home)?.error ?? "", /Directory does not exist:/);
+  assert.match(resolveCdTarget("file.txt", root, home)?.error ?? "", /Not a directory:/);
+});
+
+test("cd argument completions suggest directories and quick picks", () => {
+  const root = mkdtempSync(join(tmpdir(), "powerline-cd-complete-root-"));
+  const home = mkdtempSync(join(tmpdir(), "powerline-cd-complete-home-"));
+  mkdirSync(join(root, "child"));
+  mkdirSync(join(root, "My Folder"));
+  writeFileSync(join(root, "file.txt"), "not a directory");
+  mkdirSync(join(home, "project"));
+
+  const rootCompletions = getCdArgumentCompletions("", root, home);
+  assert.ok(rootCompletions.some((item) => item.value === "../" && item.label === "../"));
+  assert.ok(rootCompletions.some((item) => item.value === "~/" && item.label === "~/"));
+  assert.ok(rootCompletions.some((item) => item.value === "child/" && item.label === "child/"));
+  assert.ok(rootCompletions.some((item) => item.value === "My\\ Folder/" && item.label === "My Folder/"));
+  assert.ok(!rootCompletions.some((item) => item.label === "file.txt"));
+
+  if (process.platform !== "win32") {
+    assert.deepEqual(
+      getCdArgumentCompletions("~/p", root, home).map((item) => item.value),
+      ["~/project/"],
+    );
+  }
+});
+
+test("cd command cleans up the forked session when switching is cancelled", async () => {
+  const originalCwd = process.cwd();
+  const root = mkdtempSync(join(tmpdir(), "powerline-cd-command-root-"));
+  const target = join(root, "target");
+  const sessionDir = join(root, "sessions");
+  mkdirSync(target);
+
+  const session = SessionManager.create(root, sessionDir);
+  session.appendMessage({ role: "user", content: "hello", timestamp: Date.now() });
+  session.appendMessage({ role: "assistant", content: "hi", timestamp: Date.now(), usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } } });
+
+  let switchedPath: string | undefined;
+  const notifications: Array<{ message: string; type?: string }> = [];
+  const ctx = {
+    cwd: root,
+    sessionManager: {
+      getSessionFile: () => session.getSessionFile(),
+    },
+    ui: {
+      notify(message: string, type?: string) {
+        notifications.push({ message, type });
+      },
+    },
+    waitForIdle: async () => {},
+    switchSession: async (path: string) => {
+      switchedPath = path;
+      return { cancelled: true };
+    },
+  } as any;
+
+  try {
+    await runCdCommand("target", ctx);
+  } finally {
+    process.chdir(originalCwd);
+  }
+
+  assert.equal(process.cwd(), originalCwd);
+  assert.ok(switchedPath, "switchSession should receive the forked session path");
+  assert.equal(existsSync(switchedPath!), false);
+  assert.deepEqual(notifications.at(-1), { message: "Directory change cancelled", type: "warning" });
+});
+
+test("cd command preserves the target session after a post-apply switch error", async () => {
+  const originalCwd = process.cwd();
+  const root = mkdtempSync(join(tmpdir(), "powerline-cd-post-apply-root-"));
+  const target = join(root, "target");
+  const sessionDir = join(root, "sessions");
+  mkdirSync(target);
+
+  const session = SessionManager.create(root, sessionDir);
+  session.appendMessage({ role: "user", content: "hello", timestamp: Date.now() });
+  session.appendMessage({ role: "assistant", content: "hi", timestamp: Date.now(), usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } } });
+
+  let switchedPath: string | undefined;
+  const ctx = {
+    cwd: root,
+    sessionManager: {
+      getSessionFile: () => session.getSessionFile(),
+    },
+    ui: {
+      notify() {},
+    },
+    waitForIdle: async () => {},
+    switchSession: async (path: string, options: { withSession?: (ctx: any) => Promise<void> }) => {
+      switchedPath = path;
+      await options.withSession?.({
+        cwd: target,
+        ui: {
+          notify() {},
+          setTitle() {},
+        },
+      });
+      throw new Error("post-apply failure");
+    },
+  } as any;
+
+  try {
+    await runCdCommand("target", ctx);
+    assert.equal(realpathSync(process.cwd()), realpathSync(target));
+    assert.ok(switchedPath, "switchSession should receive the forked session path");
+    assert.equal(existsSync(switchedPath!), true);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("cd command uses session replacement instead of private cwd mutation", () => {
+  assert.match(indexSource, /registerCdCommand\(pi, \(\) => currentCtx\?\.cwd \?\? process\.cwd\(\)\)/);
+  assert.match(cdCommandSource, /SessionManager\.forkFrom\(sessionFile, resolved\.path\)/);
+  assert.match(cdCommandSource, /ctx\.switchSession\(nextSessionFile!/);
+  assert.match(cdCommandSource, /process\.chdir\(nextCtx\.cwd\)/);
+  assert.doesNotMatch(cdCommandSource, /ctx\.cwd\s*=/);
+});

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

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readCoreContextUsage } from "../context-usage.ts";
+import { CoreContextUsageCache, estimateInitialContextTokens, estimateUnknownContextUsage, readCoreContextUsage, resolveDisplayContextUsage } from "../context-usage.ts";
 
 test("readCoreContextUsage returns Pi context estimates for branch summaries", () => {
   const usage = readCoreContextUsage({
@@ -30,9 +30,127 @@ test("readCoreContextUsage computes percent when Pi returns only token totals",
   });
 });
 
+test("readCoreContextUsage preserves Pi's post-compaction unknown state", () => {
+  const usage = readCoreContextUsage({
+    getContextUsage() {
+      return { tokens: null, contextWindow: 5000, percent: null };
+    },
+  });
+
+  assert.deepEqual(usage, {
+    contextTokens: null,
+    contextWindow: 5000,
+    contextPercent: null,
+  });
+});
+
 test("readCoreContextUsage ignores unknown or unusable estimates", () => {
   assert.equal(readCoreContextUsage({}), null);
   assert.equal(readCoreContextUsage({ getContextUsage: () => undefined }), null);
-  assert.equal(readCoreContextUsage({ getContextUsage: () => ({ tokens: null, contextWindow: 5000, percent: null }) }), null);
+  assert.equal(readCoreContextUsage({ getContextUsage: () => ({ tokens: undefined, contextWindow: 5000, percent: null }) }), null);
   assert.equal(readCoreContextUsage({ getContextUsage: () => ({ tokens: 100, contextWindow: 0, percent: 0 }) }), null);
 });
+
+test("core context usage cache reuses a leaf and supports explicit invalidation", () => {
+  const cache = new CoreContextUsageCache();
+  let leafId = "leaf-1";
+  let tokens = 100;
+  let reads = 0;
+  const ctx = {
+    sessionManager: { getLeafId: () => leafId },
+    getContextUsage() {
+      reads += 1;
+      return { tokens, contextWindow: 1000, percent: tokens / 10 };
+    },
+  };
+
+  assert.equal(cache.get(ctx)?.contextTokens, 100);
+  tokens = 200;
+  assert.equal(cache.get(ctx)?.contextTokens, 100);
+  assert.equal(reads, 1);
+
+  cache.reset();
+  assert.equal(cache.get(ctx)?.contextTokens, 200);
+  leafId = "leaf-2";
+  tokens = 300;
+  assert.equal(cache.get(ctx)?.contextTokens, 300);
+  assert.equal(reads, 3);
+});
+
+test("resolveDisplayContextUsage preserves unknown core usage over assistant fallback usage", () => {
+  assert.deepEqual(resolveDisplayContextUsage({
+    coreContextUsage: { contextTokens: null, contextWindow: 5000, contextPercent: null },
+    unknownCoreFallback: null,
+    fallbackContextTokens: 4000,
+    fallbackContextWindow: 5000,
+  }), {
+    contextTokens: null,
+    contextWindow: 5000,
+    contextPercent: null,
+  });
+});
+
+test("resolveDisplayContextUsage uses the approximate estimate for unknown core usage", () => {
+  const reloadEstimate = { contextTokens: 1000, contextWindow: 5000, contextPercent: 20 };
+  assert.equal(resolveDisplayContextUsage({
+    coreContextUsage: { contextTokens: null, contextWindow: 5000, contextPercent: null },
+    unknownCoreFallback: reloadEstimate,
+    fallbackContextTokens: 4000,
+    fallbackContextWindow: 5000,
+  }), reloadEstimate);
+});
+
+test("resolveDisplayContextUsage computes assistant fallback usage when Pi has no current estimate", () => {
+  assert.deepEqual(resolveDisplayContextUsage({
+    coreContextUsage: null,
+    unknownCoreFallback: null,
+    fallbackContextTokens: 1000,
+    fallbackContextWindow: 4000,
+  }), {
+    contextTokens: 1000,
+    contextWindow: 4000,
+    contextPercent: 25,
+  });
+});
+
+test("estimateUnknownContextUsage estimates the active compacted context", () => {
+  const usage = estimateUnknownContextUsage({
+    getContextUsage: () => ({ tokens: null, contextWindow: 100, percent: null }),
+    getSystemPrompt: () => "12345678",
+    sessionManager: {
+      buildContextEntries: () => [
+        { type: "compaction", summary: "12345678", tokensBefore: 90, timestamp: "2026-08-08T00:00:00.000Z" },
+        { type: "message", message: { role: "user", content: "1234", timestamp: 0 } },
+      ],
+    },
+  });
+
+  assert.deepEqual(usage, {
+    contextTokens: 5,
+    contextWindow: 100,
+    contextPercent: 5,
+  });
+});
+
+test("estimateUnknownContextUsage skips sessions with known core usage", () => {
+  let entryReads = 0;
+  assert.equal(estimateUnknownContextUsage({
+    getContextUsage: () => ({ tokens: 25, contextWindow: 100, percent: 25 }),
+    getSystemPrompt: () => "12345678",
+    sessionManager: {
+      buildContextEntries() {
+        entryReads += 1;
+        return [];
+      },
+    },
+  }), null);
+  assert.equal(entryReads, 0);
+});
+
+test("estimateInitialContextTokens uses Pi's conservative character estimate", () => {
+  assert.equal(estimateInitialContextTokens({}), null);
+  assert.equal(estimateInitialContextTokens({ getSystemPrompt: () => "" }), null);
+  assert.equal(estimateInitialContextTokens({ getSystemPrompt: () => "   " }), null);
+  assert.equal(estimateInitialContextTokens({ getSystemPrompt: () => "1234" }), 1);
+  assert.equal(estimateInitialContextTokens({ getSystemPrompt: () => "12345" }), 2);
+});

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

@@ -1,6 +1,12 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { collectHiddenExtensionStatusKeys, getNotificationExtensionStatuses, normalizeExtensionStatusValue, parsePowerlineConfig, mergeSegmentsWithCustomItems, nextPowerlineSettingWithOptions, nextPowerlineSettingWithPreset, normalizeCompactExtensionStatus } from "../powerline-config.ts";
+import { collectHiddenExtensionStatusKeys, getNotificationExtensionStatuses, normalizeExtensionStatusValue, parsePowerlineConfig, mergeSegmentOptions, mergeSegmentsWithCustomItems, nextPowerlineSettingWithOptions, nextPowerlineSettingWithPreset, normalizeCompactExtensionStatus } from "../powerline-config.ts";
+import { getSeparator } from "../separators.ts";
+import { PRESETS } from "../presets.ts";
+
+test("fixed custom preset is removed in favor of powerline.layout", () => {
+  assert.equal("custom" in PRESETS, false);
+});
 
 test("parsePowerlineConfig supports object config with custom items", () => {
   const config = parsePowerlineConfig(
@@ -20,28 +26,204 @@ test("parsePowerlineConfig supports object config with custom items", () => {
   assert.equal(config.customItems[0].statusKey, "ci-status");
   assert.equal(config.customItems[1].statusKey, "review");
   assert.equal(config.customItems[1].hideWhenMissing, false);
-  assert.equal(config.mouseScroll, true);
-  assert.equal(config.fixedEditor, true);
+  assert.deepEqual(config.disabledSegments, []);
+  assert.deepEqual(config.invalidDisabledSegments, []);
+  assert.equal(config.layout, null);
+  assert.deepEqual(config.invalidLayoutSegments, []);
+  assert.equal(config.separator, null);
+  assert.equal(config.placement, "above");
+  assert.equal(config.invalidPlacement, null);
+  assert.equal(config.welcome, true);
+  assert.equal(config.stashSharpSShortcut, false);
+  assert.deepEqual(config.queue, { captureSigil: "#" });
 });
 
-test("parsePowerlineConfig supports disabling mouse scroll", () => {
+test("parsePowerlineConfig supports disabled segments", () => {
   const config = parsePowerlineConfig(
-    { preset: "compact", mouseScroll: false },
+    {
+      preset: "default",
+      customItems: [{ id: "ci" }],
+      disabledSegments: [
+        "queue",
+        "cost",
+        " extension_statuses ",
+        "custom:ci",
+        "cost",
+        "unknown",
+        "custom:missing",
+        123,
+      ],
+    },
     ["default", "compact"],
   );
 
-  assert.equal(config.preset, "compact");
-  assert.equal(config.mouseScroll, false);
+  assert.deepEqual(config.disabledSegments, ["queue", "cost", "extension_statuses", "custom:ci"]);
+  assert.deepEqual(config.invalidDisabledSegments, ["unknown", "custom:missing", "123"]);
 });
 
-test("parsePowerlineConfig supports disabling fixed editor", () => {
+test("parsePowerlineConfig supports partial explicit layout rows", () => {
   const config = parsePowerlineConfig(
-    { preset: "compact", fixedEditor: false },
+    {
+      preset: "default",
+      customItems: [{ id: "ci" }],
+      layout: {
+        left: ["model", "custom:ci", "model", "unknown", 123],
+        right: ["model", "cost"],
+        secondary: [],
+      },
+    },
     ["default", "compact"],
   );
 
-  assert.equal(config.preset, "compact");
-  assert.equal(config.fixedEditor, false);
+  assert.deepEqual(config.layout, {
+    left: ["model", "custom:ci"],
+    right: ["cost"],
+    secondary: [],
+  });
+  assert.deepEqual(config.invalidLayoutSegments, ["left:unknown", "left:123", "right:model"]);
+});
+
+test("parsePowerlineConfig preserves reporter layout groups", () => {
+  const config = parsePowerlineConfig(
+    {
+      preset: "default",
+      layout: {
+        left: ["model"],
+        right: ["path"],
+        secondary: ["thinking"],
+      },
+    },
+    ["default", "compact"],
+  );
+
+  assert.deepEqual(config.layout, {
+    left: ["model"],
+    right: ["path"],
+    secondary: ["thinking"],
+  });
+  assert.deepEqual(config.invalidLayoutSegments, []);
+  assert.deepEqual(
+    mergeSegmentsWithCustomItems(PRESETS.default, config.customItems, {
+      layout: config.layout,
+      disabledSegments: config.disabledSegments,
+    }),
+    {
+      leftSegments: ["model"],
+      rightSegments: ["path"],
+      secondarySegments: ["thinking"],
+    },
+  );
+});
+
+test("parsePowerlineConfig supports separator overrides", () => {
+  const config = parsePowerlineConfig(
+    { preset: "default", separator: " chevron " },
+    ["default", "compact"],
+  );
+  const invalid = parsePowerlineConfig(
+    { preset: "default", separator: "sparkle" },
+    ["default", "compact"],
+  );
+
+  assert.equal(config.separator, "chevron");
+  assert.equal(invalid.separator, null);
+});
+
+test("configured separators resolve independently of presets", () => {
+  const presetSeparator = getSeparator(PRESETS.default.separator).left;
+  const configuredSeparator = getSeparator("chevron").left;
+
+  assert.notEqual(configuredSeparator, presetSeparator);
+  assert.equal(configuredSeparator, "›");
+});
+
+test("parsePowerlineConfig validates primary powerline placement", () => {
+  const below = parsePowerlineConfig(
+    { preset: "compact", placement: "below" },
+    ["default", "compact"],
+  );
+  const invalid = parsePowerlineConfig(
+    { preset: "compact", placement: "sideways" },
+    ["default", "compact"],
+  );
+
+  assert.equal(below.placement, "below");
+  assert.equal(below.invalidPlacement, null);
+  assert.equal(invalid.placement, "above");
+  assert.equal(invalid.invalidPlacement, "sideways");
+});
+
+
+
+
+test("parsePowerlineConfig supports welcome, legacy sharp-S, and queue capture settings", () => {
+  const disabled = parsePowerlineConfig(
+    { preset: "compact", welcome: false, stashSharpSShortcut: true, queue: { captureSigil: false } },
+    ["default", "compact"],
+  );
+  const customSigil = parsePowerlineConfig(
+    { preset: "compact", queue: { captureSigil: "//" } },
+    ["default", "compact"],
+  );
+  const invalidSigil = parsePowerlineConfig(
+    { preset: "compact", queue: { captureSigil: "# note" } },
+    ["default", "compact"],
+  );
+  const shorthand = parsePowerlineConfig("compact", ["default", "compact"]);
+
+  assert.equal(disabled.welcome, false);
+  assert.equal(disabled.stashSharpSShortcut, true);
+  assert.deepEqual(disabled.queue, { captureSigil: false });
+  assert.deepEqual(customSigil.queue, { captureSigil: "//" });
+  assert.deepEqual(invalidSigil.queue, { captureSigil: "#" });
+  assert.equal(shorthand.welcome, true);
+  assert.equal(shorthand.stashSharpSShortcut, false);
+  assert.deepEqual(shorthand.queue, { captureSigil: "#" });
+});
+
+test("parsePowerlineConfig extracts supported segment options", () => {
+  const config = parsePowerlineConfig(
+    {
+      preset: "default",
+      model: { showThinkingLevel: true, display: "qualified" },
+      path: { mode: "full", maxLength: 120 },
+      git: { showBranch: false, showStaged: false, showUnstaged: true, showUntracked: false, polling: "branch", hostIcon: true },
+      time: { format: "12h", showSeconds: true },
+      cost: { subscriptionDisplay: "both", currency: "cny" },
+    },
+    ["default", "compact"],
+  );
+  const invalidCurrency = parsePowerlineConfig(
+    { cost: { currency: "BTC" } },
+    ["default", "compact"],
+  );
+
+  assert.deepEqual(config.segmentOptions, {
+    model: { showThinkingLevel: true, display: "qualified" },
+    path: { mode: "full", maxLength: 120 },
+    git: { showBranch: false, showStaged: false, showUnstaged: true, showUntracked: false, polling: "branch", hostIcon: true },
+    time: { format: "12h", showSeconds: true },
+    cost: { subscriptionDisplay: "both", currency: "CNY" },
+  });
+  assert.deepEqual(invalidCurrency.segmentOptions, { cost: {} });
+});
+
+test("mergeSegmentOptions lets user config override preset segment defaults", () => {
+  assert.deepEqual(
+    mergeSegmentOptions(
+      { path: { mode: "basename", maxLength: 20 }, git: { showBranch: true, showUntracked: true } },
+      { path: { mode: "full" }, git: { showUntracked: false }, cost: { subscriptionDisplay: "reported-cost" } },
+    ),
+    {
+      model: {},
+      path: { mode: "full", maxLength: 20 },
+      git: { showBranch: true, showUntracked: false },
+      time: {},
+      cost: { subscriptionDisplay: "reported-cost" },
+      context: {},
+      cache_read: {},
+    },
+  );
 });
 
 test("mergeSegmentsWithCustomItems appends custom segment ids by position", () => {
@@ -64,6 +246,53 @@ test("mergeSegmentsWithCustomItems appends custom segment ids by position", () =
   assert.deepEqual(merged.secondarySegments, ["extension_statuses", "custom:review"]);
 });
 
+test("mergeSegmentsWithCustomItems filters disabled segment ids", () => {
+  const merged = mergeSegmentsWithCustomItems(
+    {
+      leftSegments: ["path", "model"],
+      rightSegments: ["git", "cost"],
+      secondarySegments: ["extension_statuses"],
+      separator: "powerline",
+    },
+    [
+      { id: "ci", statusKey: "ci", position: "left", hideWhenMissing: true, excludeFromExtensionStatuses: true },
+      { id: "timer", statusKey: "timer", position: "right", hideWhenMissing: true, excludeFromExtensionStatuses: true },
+      { id: "review", statusKey: "review", position: "secondary", hideWhenMissing: true, excludeFromExtensionStatuses: true },
+    ],
+    { disabledSegments: ["model", "cost", "custom:ci", "custom:review"] },
+  );
+
+  assert.deepEqual(merged.leftSegments, ["path"]);
+  assert.deepEqual(merged.rightSegments, ["git", "custom:timer"]);
+  assert.deepEqual(merged.secondarySegments, ["extension_statuses"]);
+});
+
+test("mergeSegmentsWithCustomItems applies partial layout rows before disabled filtering", () => {
+  const merged = mergeSegmentsWithCustomItems(
+    {
+      leftSegments: ["path", "model"],
+      rightSegments: ["git", "cost", "extension_statuses"],
+      secondarySegments: ["extension_statuses"],
+      separator: "powerline",
+    },
+    [
+      { id: "ci", statusKey: "ci", position: "right", hideWhenMissing: true, excludeFromExtensionStatuses: true },
+      { id: "review", statusKey: "review", position: "secondary", hideWhenMissing: true, excludeFromExtensionStatuses: true },
+    ],
+    {
+      layout: {
+        left: ["model", "custom:ci", "extension_statuses"],
+        secondary: [],
+      },
+      disabledSegments: ["model"],
+    },
+  );
+
+  assert.deepEqual(merged.leftSegments, ["custom:ci", "extension_statuses"]);
+  assert.deepEqual(merged.rightSegments, ["git", "cost"]);
+  assert.deepEqual(merged.secondarySegments, []);
+});
+
 test("nextPowerlineSettingWithPreset preserves object settings", () => {
   const updated = nextPowerlineSettingWithPreset({ preset: "default", customItems: [{ id: "ci" }] }, "compact");
   if (typeof updated !== "object" || updated === null || Array.isArray(updated)) {
@@ -82,24 +311,18 @@ test("nextPowerlineSettingWithPreset preserves object settings", () => {
 
 test("nextPowerlineSettingWithOptions preserves object settings", () => {
   const updated = nextPowerlineSettingWithOptions(
-    { preset: "default", customItems: [{ id: "ci" }], mouseScroll: false },
-    { fixedEditor: false },
+    { preset: "default", customItems: [{ id: "ci" }] },
+    { placement: "below" },
     "compact",
   );
-  if (typeof updated !== "object" || updated === null || Array.isArray(updated)) {
-    assert.fail("expected an object powerline setting");
-  }
 
-  assert.equal(updated.preset, "default");
-  assert.equal(updated.fixedEditor, false);
-  assert.equal(updated.mouseScroll, false);
-  assert.deepEqual(updated.customItems, [{ id: "ci" }]);
+  assert.deepEqual(updated, { preset: "default", customItems: [{ id: "ci" }], placement: "below" });
 });
 
 test("nextPowerlineSettingWithOptions converts string presets to object settings", () => {
-  assert.deepEqual(nextPowerlineSettingWithOptions("compact", { mouseScroll: true }, "compact"), {
+  assert.deepEqual(nextPowerlineSettingWithOptions("compact", { placement: "below" }, "compact"), {
     preset: "compact",
-    mouseScroll: true,
+    placement: "below",
   });
 });
 

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

@@ -0,0 +1,48 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import type { AutocompleteProvider } from "@earendil-works/pi-tui";
+import { getEditorAutocompleteProvider, passAutocompleteProviderThroughPreviousEditor } from "../editor-composition.ts";
+
+function baseProvider(): AutocompleteProvider {
+  return {
+    async getSuggestions() {
+      return {
+        prefix: "@",
+        items: [{ label: "base", value: "base" }],
+      };
+    },
+    applyCompletion(lines, cursorLine, cursorCol) {
+      return { lines, cursorLine, cursorCol };
+    },
+  };
+}
+
+test("previous editor autocomplete provider wrappers are preserved", async () => {
+  const previousEditor = {
+    autocompleteProvider: undefined as AutocompleteProvider | undefined,
+    setAutocompleteProvider(provider: AutocompleteProvider) {
+      this.autocompleteProvider = {
+        async getSuggestions(lines, cursorLine, cursorCol, context) {
+          const suggestions = await provider.getSuggestions(lines, cursorLine, cursorCol, context);
+          return {
+            ...suggestions,
+            items: [...suggestions.items, { label: "previous-wrapper", value: "previous-wrapper" }],
+          };
+        },
+        applyCompletion: provider.applyCompletion.bind(provider),
+      };
+    },
+  };
+
+  const composed = passAutocompleteProviderThroughPreviousEditor(baseProvider(), previousEditor);
+  const suggestions = await composed.getSuggestions(["@"], 0, 1, { signal: new AbortController().signal });
+
+  assert.equal(composed, previousEditor.autocompleteProvider);
+  assert.deepEqual(suggestions.items.map((item) => item.label), ["base", "previous-wrapper"]);
+});
+
+test("autocomplete provider detection rejects incomplete editor providers", () => {
+  assert.equal(getEditorAutocompleteProvider({ autocompleteProvider: {} }), undefined);
+  assert.equal(getEditorAutocompleteProvider({ autocompleteProvider: { getSuggestions() {} } }), undefined);
+  assert.ok(getEditorAutocompleteProvider({ autocompleteProvider: baseProvider() }));
+});

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

@@ -34,6 +34,40 @@ test("render scheduler coalesces pending status renders", () => {
   }
 });
 
+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> = [];