@selesai/code 0.6.3 → 0.8.0

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

@@ -0,0 +1,249 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { computeSessionTokenStats, SessionBranchCache, SessionTokenStatsCache } from "../token-stats.ts";
+
+function makeUsage(input: number, output: number, cacheRead = 0, cacheWrite = 0, costPerToken = 0.001) {
+  return {
+    input,
+    output,
+    cacheRead,
+    cacheWrite,
+    cost: { total: (input + output + cacheRead + cacheWrite) * costPerToken },
+  };
+}
+
+function assistantEvent(usage: ReturnType<typeof makeUsage>, stopReason: string = "stop") {
+  return {
+    type: "message",
+    message: {
+      role: "assistant",
+      content: [{ type: "text", text: "hi" }],
+      usage,
+      stopReason,
+    },
+  };
+}
+
+function userEvent() {
+  return {
+    type: "message",
+    message: { role: "user", content: [{ type: "text", text: "hello" }] },
+  };
+}
+
+function subagentToolResultEvent(costs: number[]) {
+  return {
+    type: "message",
+    message: {
+      role: "toolResult",
+      toolName: "subagent",
+      details: { results: costs.map((cost) => ({ usage: { cost } })) },
+    },
+  };
+}
+
+function subagentSlashResultEvent(costs: number[]) {
+  return {
+    type: "custom_message",
+    customType: "subagent-slash-result",
+    details: { result: { details: { results: costs.map((cost) => ({ usage: { cost } })) } } },
+  };
+}
+
+test("session branch cache reuses a leaf path and refreshes when the leaf changes", () => {
+  const cache = new SessionBranchCache();
+  let leafId = "leaf-1";
+  let branch: unknown[] = [{ id: leafId, value: 1 }];
+  let branchReads = 0;
+  const provider = {
+    getLeafId: () => leafId,
+    getBranch: () => {
+      branchReads += 1;
+      return branch;
+    },
+  };
+
+  assert.deepEqual(cache.get(null), []);
+
+  const first = cache.get(provider);
+  (branch[0] as { value: number }).value = 2;
+  assert.equal(cache.get(provider), first);
+  assert.equal((cache.get(provider)[0] as { value: number }).value, 2);
+  assert.equal(branchReads, 1);
+
+  leafId = "leaf-2";
+  branch = [...branch, { id: leafId }];
+  assert.equal(cache.get(provider), branch);
+  assert.equal(branchReads, 2);
+
+  cache.reset();
+  cache.get(provider);
+  assert.equal(branchReads, 3);
+});
+
+test("computeSessionTokenStats aggregates usage and tracks thinking level", () => {
+  const events = [
+    userEvent(),
+    { type: "thinking_level_change", thinkingLevel: "high" },
+    assistantEvent(makeUsage(10, 5)),
+    assistantEvent(makeUsage(20, 7, 3, 2), "error"), // skipped: error
+    assistantEvent(makeUsage(30, 9, 4, 1), "aborted"), // skipped: aborted
+    assistantEvent(makeUsage(40, 11, 6, 2)),
+  ];
+
+  const stats = computeSessionTokenStats(events);
+
+  assert.equal(stats.input, 50);
+  assert.equal(stats.output, 16);
+  assert.equal(stats.cacheRead, 6);
+  assert.equal(stats.cacheWrite, 2);
+  assert.ok(Math.abs(stats.cost - 0.074) < 1e-12);
+  assert.equal(stats.lastAssistant, (events[5] as any).message);
+  assert.equal(stats.thinkingLevelFromSession, "high");
+});
+
+test("computeSessionTokenStats sums subagent child run cost from tool results and slash results", () => {
+  const events = [
+    userEvent(),
+    assistantEvent(makeUsage(10, 5)),
+    subagentToolResultEvent([0.12, 0.34]),
+    subagentSlashResultEvent([0.5]),
+  ];
+
+  const stats = computeSessionTokenStats(events);
+  assert.ok(Math.abs(stats.subagentCost - 0.96) < 1e-12);
+});
+
+test("computeSessionTokenStats ignores assistant messages without tokens for lastAssistant", () => {
+  const events = [
+    assistantEvent(makeUsage(10, 5)),
+    assistantEvent(makeUsage(0, 0)),
+  ];
+
+  const stats = computeSessionTokenStats(events);
+  assert.equal(stats.lastAssistant, (events[0] as any).message);
+});
+
+test("cache reuses stats object while session is unchanged", () => {
+  const cache = new SessionTokenStatsCache();
+  const events = [userEvent(), assistantEvent(makeUsage(10, 5))];
+
+  const first = cache.get(events);
+  const second = cache.get(events);
+
+  assert.equal(second, first);
+});
+
+test("cache recomputes when events are appended", () => {
+  const cache = new SessionTokenStatsCache();
+  const events = [assistantEvent(makeUsage(10, 5))];
+
+  const first = cache.get(events);
+  events.push(assistantEvent(makeUsage(20, 7)));
+  const second = cache.get(events);
+
+  assert.notEqual(second, first);
+  assert.equal(second.input, 30);
+  assert.equal(second.output, 12);
+});
+
+test("cache recomputes when the last event is updated in place (streaming)", () => {
+  const cache = new SessionTokenStatsCache();
+  const tail = assistantEvent(makeUsage(10, 5), "streaming");
+  const events = [userEvent(), tail];
+
+  const first = cache.get(events);
+  assert.equal(first.output, 5);
+
+  // Streaming updates the trailing assistant message in place: same event
+  // count, same object references, fresh usage numbers.
+  tail.message.usage = makeUsage(10, 42);
+  tail.message.stopReason = "stop";
+
+  const second = cache.get(events);
+  assert.notEqual(second, first);
+  assert.equal(second.output, 42);
+  assert.equal(second.lastAssistant, tail.message);
+});
+
+test("cache recomputes when the last subagent result cost is updated in place", () => {
+  const cache = new SessionTokenStatsCache();
+  const tail = subagentToolResultEvent([0.1]);
+  const events = [assistantEvent(makeUsage(10, 5)), tail];
+
+  const first = cache.get(events);
+  assert.equal(first.subagentCost, 0.1);
+
+  tail.message.details.results = [{ usage: { cost: 0.3 } }];
+
+  const second = cache.get(events);
+  assert.notEqual(second, first);
+  assert.equal(second.subagentCost, 0.3);
+});
+
+test("cache recomputes when the last event turns into an error in place", () => {
+  const cache = new SessionTokenStatsCache();
+  const tail = assistantEvent(makeUsage(10, 5));
+  const events = [assistantEvent(makeUsage(1, 1)), tail];
+
+  const first = cache.get(events);
+  assert.equal(first.input, 11);
+
+  tail.message.stopReason = "error";
+
+  const second = cache.get(events);
+  assert.notEqual(second, first);
+  assert.equal(second.input, 1);
+});
+
+test("cache recomputes when the last event is replaced with a same-sized list", () => {
+  const cache = new SessionTokenStatsCache();
+  const events = [userEvent(), assistantEvent(makeUsage(10, 5))];
+
+  const first = cache.get(events);
+  events[1] = assistantEvent(makeUsage(10, 5));
+  const second = cache.get(events);
+
+  assert.notEqual(second, first);
+  assert.deepEqual(
+    { input: second.input, output: second.output },
+    { input: first.input, output: first.output },
+  );
+});
+
+test("cache does not rescan for in-place changes to non-trailing events", () => {
+  const cache = new SessionTokenStatsCache();
+  const head = assistantEvent(makeUsage(10, 5));
+  const events = [head, assistantEvent(makeUsage(20, 7))];
+
+  const first = cache.get(events);
+
+  // Historical events are treated as immutable; only the trailing event is
+  // re-validated. This documents the cache's correctness boundary.
+  head.message.usage = makeUsage(999, 999);
+  const second = cache.get(events);
+
+  assert.equal(second, first);
+  assert.equal(second.input, 30);
+});
+
+test("reset forces recomputation", () => {
+  const cache = new SessionTokenStatsCache();
+  const events = [assistantEvent(makeUsage(10, 5))];
+
+  const first = cache.get(events);
+  cache.reset();
+  const second = cache.get(events);
+
+  assert.notEqual(second, first);
+  assert.equal(second.input, first.input);
+});
+
+test("index.ts wires the token stats cache into buildSegmentContext", () => {
+  const source = readFileSync(new URL("../index.ts", import.meta.url), "utf-8");
+  assert.match(source, /import \{ SessionBranchCache, SessionTokenStatsCache \} from "\.\/token-stats\.ts";/);
+  assert.match(source, /sessionBranchCache\.get\(ctx\.sessionManager\)/);
+  assert.match(source, /tokenStatsCache\.get\(sessionEvents\)/);
+  assert.match(source, /tokenStatsCache\.reset\(\)/);
+});

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

@@ -0,0 +1,237 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { renderSegment } from "../segments.ts";
+import { mergeSegmentOptions, parsePowerlineConfig } from "../powerline-config.ts";
+import type { SegmentContext, StatusLineSegmentOptions } from "../types.ts";
+
+const PRESET_NAMES = ["default", "compact"];
+
+const originalNerdFonts = process.env.POWERLINE_NERD_FONTS;
+process.env.POWERLINE_NERD_FONTS = "0";
+
+test.after(() => {
+  if (originalNerdFonts === undefined) {
+    delete process.env.POWERLINE_NERD_FONTS;
+  } else {
+    process.env.POWERLINE_NERD_FONTS = originalNerdFonts;
+  }
+});
+
+function stripAnsi(text: string): string {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+function plainTheme(): any {
+  return {
+    fg: (_color: string, text: string) => text,
+    bg: (_color: string, text: string) => text,
+    bold: (text: string) => text,
+  };
+}
+
+function createSegmentContext(options: StatusLineSegmentOptions = {}, overrides: Partial<SegmentContext> = {}): SegmentContext {
+  return {
+    model: undefined,
+    thinkingLevel: "off",
+    sessionId: undefined,
+    usageStats: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, subagentCost: 0 },
+    contextTokens: 0,
+    contextPercent: 0,
+    contextWindow: 0,
+    contextApproximate: false,
+    autoCompactEnabled: true,
+    customCompactionEnabled: false,
+    usingSubscription: false,
+    queueSummary: { queueCount: 0, ideaCount: 0, blockedCount: 0, compacting: false, leadingText: null, leadingIntent: null, leadingStatus: null },
+    sessionStartTime: Date.now(),
+    shellModeActive: false,
+    shellRunning: false,
+    shellName: null,
+    shellCwd: null,
+    git: { branch: null, staged: 0, unstaged: 0, untracked: 0 },
+    extensionStatuses: new Map(),
+    hiddenExtensionStatusKeys: new Set(),
+    customItemsById: new Map(),
+    options,
+    theme: plainTheme(),
+    colors: {},
+    ...overrides,
+  };
+}
+
+// ── context_pct format ──────────────────────────────────────────────────────
+
+test("context_pct defaults to the full tokens/window rendering", () => {
+  const ctx = createSegmentContext({}, {
+    contextTokens: 12300,
+    contextWindow: 200000,
+    contextPercent: 6.15,
+  });
+
+  const rendered = renderSegment("context_pct", ctx);
+  assert.equal(stripAnsi(rendered.content), "12k/200k (6.2%)");
+});
+
+test("context_pct percent format renders a bare rounded percentage", () => {
+  const ctx = createSegmentContext({ context: { format: "percent" } }, {
+    contextTokens: 12300,
+    contextWindow: 200000,
+    contextPercent: 6.15,
+  });
+
+  const rendered = renderSegment("context_pct", ctx);
+  assert.equal(stripAnsi(rendered.content), "6%");
+});
+
+test("context_pct renders unknown usage after compaction", () => {
+  const full = createSegmentContext({}, {
+    contextTokens: null,
+    contextWindow: 200000,
+    contextPercent: null,
+  });
+  const percent = createSegmentContext({ context: { format: "percent" } }, {
+    contextTokens: null,
+    contextWindow: 200000,
+    contextPercent: null,
+  });
+
+  assert.equal(stripAnsi(renderSegment("context_pct", full).content), "?/200k");
+  assert.equal(stripAnsi(renderSegment("context_pct", percent).content), "?");
+});
+
+test("context_pct marks context estimates as approximate", () => {
+  const full = createSegmentContext({}, {
+    contextTokens: 18000,
+    contextWindow: 272000,
+    contextPercent: 6.6176,
+    contextApproximate: true,
+  });
+  const percent = createSegmentContext({ context: { format: "percent" } }, {
+    contextTokens: 18000,
+    contextWindow: 272000,
+    contextPercent: 6.6176,
+    contextApproximate: true,
+  });
+
+  assert.equal(stripAnsi(renderSegment("context_pct", full).content), "~18k/272k (6.6%)");
+  assert.equal(stripAnsi(renderSegment("context_pct", percent).content), "~7%");
+});
+
+test("context_pct percent format keeps threshold colors and drops icons", () => {
+  for (const [percent, expected] of [[69, "69%"], [85, "85%"], [95, "95%"]] as const) {
+    const ctx = createSegmentContext({ context: { format: "percent" } }, {
+      contextTokens: percent,
+      contextWindow: 100,
+      contextPercent: percent,
+    });
+    const rendered = renderSegment("context_pct", ctx);
+    assert.equal(stripAnsi(rendered.content), expected);
+    assert.ok(!rendered.content.includes("◫"), "no context icon in percent mode");
+    assert.ok(!rendered.content.includes("AC"), "no auto-compact icon in percent mode");
+  }
+});
+
+// ── cache_read format ───────────────────────────────────────────────────────
+
+test("cache_read defaults to raw token count", () => {
+  const ctx = createSegmentContext({}, {
+    usageStats: { input: 1000, output: 0, cacheRead: 12300, cacheWrite: 0, cost: 0, subagentCost: 0 },
+  });
+
+  const rendered = renderSegment("cache_read", ctx);
+  assert.equal(stripAnsi(rendered.content), "cache in: 12k");
+});
+
+test("cache_read percent format renders the cache hit rate", () => {
+  const ctx = createSegmentContext({ cache_read: { format: "percent" } }, {
+    usageStats: { input: 2000, output: 0, cacheRead: 8000, cacheWrite: 0, cost: 0, subagentCost: 0 },
+  });
+
+  const rendered = renderSegment("cache_read", ctx);
+  assert.equal(stripAnsi(rendered.content), "cache 80%");
+});
+
+test("cache_read both format renders raw token count and cache hit rate", () => {
+  const ctx = createSegmentContext({ cache_read: { format: "both" } }, {
+    usageStats: { input: 2000, output: 0, cacheRead: 8000, cacheWrite: 0, cost: 0, subagentCost: 0 },
+  });
+
+  const rendered = renderSegment("cache_read", ctx);
+  assert.equal(stripAnsi(rendered.content), "cache in: 8.0k (80%)");
+});
+
+test("cache_read percent and both formats handle zero input without NaN", () => {
+  const percentCtx = createSegmentContext({ cache_read: { format: "percent" } }, {
+    usageStats: { input: 0, output: 0, cacheRead: 5, cacheWrite: 0, cost: 0, subagentCost: 0 },
+  });
+  assert.equal(stripAnsi(renderSegment("cache_read", percentCtx).content), "cache 100%");
+
+  const bothCtx = createSegmentContext({ cache_read: { format: "both" } }, {
+    usageStats: { input: 0, output: 0, cacheRead: 5, cacheWrite: 0, cost: 0, subagentCost: 0 },
+  });
+  assert.equal(stripAnsi(renderSegment("cache_read", bothCtx).content), "cache in: 5 (100%)");
+
+  const hidden = createSegmentContext({ cache_read: { format: "both" } });
+  assert.deepEqual(renderSegment("cache_read", hidden), { content: "", visible: false });
+});
+
+// ── queue segment ──────────────────────────────────────────────────────────
+
+test("queue segment hides when empty", () => {
+  const ctx = createSegmentContext();
+  assert.deepEqual(renderSegment("queue", ctx), { content: "", visible: false });
+});
+
+test("queue segment summarizes queued ideas and blocked items", () => {
+  const ctx = createSegmentContext({}, {
+    queueSummary: { queueCount: 2, ideaCount: 3, blockedCount: 1, compacting: false, leadingText: "fix README", leadingIntent: "post-compact", leadingStatus: "blocked" },
+  });
+
+  assert.equal(stripAnsi(renderSegment("queue", ctx).content), "q 2 · ideas 3 · blocked 1");
+});
+
+test("queue segment highlights compaction-held prompts", () => {
+  const ctx = createSegmentContext({}, {
+    queueSummary: { queueCount: 1, ideaCount: 0, blockedCount: 0, compacting: true, leadingText: "run after compact", leadingIntent: "post-compact", leadingStatus: "queued" },
+  });
+
+  assert.equal(stripAnsi(renderSegment("queue", ctx).content), "compact q 1");
+});
+
+// ── config parsing / merging ────────────────────────────────────────────────
+
+test("parsePowerlineConfig accepts context and cache_read formats", () => {
+  const config = parsePowerlineConfig({
+    context: { format: "percent" },
+    cache_read: { format: "both" },
+  }, PRESET_NAMES);
+
+  assert.equal(config.segmentOptions.context?.format, "percent");
+  assert.equal(config.segmentOptions.cache_read?.format, "both");
+});
+
+test("parsePowerlineConfig ignores invalid format values", () => {
+  const config = parsePowerlineConfig({
+    context: { format: "bogus" },
+    cache_read: { format: 42 },
+  }, PRESET_NAMES);
+
+  assert.equal(config.segmentOptions.context?.format, undefined);
+  assert.equal(config.segmentOptions.cache_read?.format, undefined);
+});
+
+test("parsePowerlineConfig defaults to upstream rendering when options are absent", () => {
+  const config = parsePowerlineConfig({}, PRESET_NAMES);
+  assert.equal(config.segmentOptions.context, undefined);
+  assert.equal(config.segmentOptions.cache_read, undefined);
+});
+
+test("mergeSegmentOptions merges context and cache_read per key", () => {
+  const merged = mergeSegmentOptions(
+    { context: { format: "percent" }, cache_read: { format: "percent" } },
+    { context: { format: "full" }, cache_read: { format: "both" } },
+  );
+
+  assert.equal(merged.context?.format, "full");
+  assert.equal(merged.cache_read?.format, "both");
+});

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

@@ -0,0 +1,199 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { discoverLoadedCounts, getRecentSessions, WelcomeHeader } from "../welcome.ts";
+
+const indexSource = readFileSync(new URL("../index.ts", import.meta.url), "utf8");
+
+test("discoverLoadedCounts ignores dangling skill symlinks", () => {
+  const root = mkdtempSync(join(tmpdir(), "powerline-welcome-"));
+  const home = join(root, "home");
+  const project = join(root, "project");
+  const skillsDir = join(home, ".selesai", "agent", "skills");
+  const originalHome = process.env.HOME;
+  const originalAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+  const originalCwd = process.cwd();
+  const originalDebug = console.debug;
+  const debugCalls: unknown[][] = [];
+
+  mkdirSync(join(skillsDir, "valid-skill"), { recursive: true });
+  mkdirSync(project, { recursive: true });
+  writeFileSync(join(skillsDir, "valid-skill", "SKILL.md"), "# Valid skill\n");
+  symlinkSync(join(root, "missing-skill"), join(skillsDir, "pi-intercom"), "dir");
+
+  console.debug = (...args: unknown[]) => {
+    debugCalls.push(args);
+  };
+
+  try {
+    process.env.HOME = home;
+    delete process.env.SELESAI_CODING_AGENT_DIR;
+    process.chdir(project);
+
+    assert.equal(discoverLoadedCounts().skills, 1);
+    assert.deepEqual(debugCalls, []);
+  } finally {
+    console.debug = originalDebug;
+    process.chdir(originalCwd);
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    if (originalAgentDir === undefined) {
+      delete process.env.SELESAI_CODING_AGENT_DIR;
+    } else {
+      process.env.SELESAI_CODING_AGENT_DIR = originalAgentDir;
+    }
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+function withTemporaryHome(run: (home: string) => void): void {
+  const home = mkdtempSync(join(tmpdir(), "powerline-welcome-home-"));
+  const originalHome = process.env.HOME;
+  const originalAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+
+  try {
+    process.env.HOME = home;
+    delete process.env.SELESAI_CODING_AGENT_DIR;
+    run(home);
+  } finally {
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    if (originalAgentDir === undefined) {
+      delete process.env.SELESAI_CODING_AGENT_DIR;
+    } else {
+      process.env.SELESAI_CODING_AGENT_DIR = originalAgentDir;
+    }
+    rmSync(home, { recursive: true, force: true });
+  }
+}
+
+test("welcome renders the initial system prompt token estimate", () => {
+  const counts = { contextFiles: 1, extensions: 1, skills: 1, promptTemplates: 1 };
+  const rendered = new WelcomeHeader("Model", "Provider", [], counts, "compact", [], 1900)
+    .render(96)
+    .join("\n")
+    .replace(/\x1b\[[0-9;]*m/g, "");
+  const withoutEstimate = [undefined, 0, Number.NaN].map((tokens) => new WelcomeHeader(
+    "Model",
+    "Provider",
+    [],
+    counts,
+    "compact",
+    [],
+    tokens,
+  ).render(96).join("\n").replace(/\x1b\[[0-9;]*m/g, ""));
+
+  assert.match(rendered, /≈ 1\.9k initial prompt tokens/);
+  for (const output of withoutEstimate) {
+    assert.doesNotMatch(output, /initial prompt tokens/);
+  }
+  assert.match(indexSource, /new WelcomeHeader\(modelName, providerName, recentSessions, loadedCounts, "compact", newFeatures, initialContextTokens\)/);
+
+  const overlayStart = indexSource.indexOf("function setupWelcomeOverlay");
+  const delayStart = indexSource.indexOf("setTimeout(() => {", overlayStart);
+  const activityGuardStart = indexSource.indexOf("if (hasActivity) {", delayStart);
+  const estimateStart = indexSource.indexOf("const initialContextTokens = estimateInitialContextTokens(ctx);", overlayStart);
+  const componentStart = indexSource.indexOf("new WelcomeComponent(", overlayStart);
+  assert.ok(overlayStart >= 0);
+  assert.ok(delayStart > overlayStart);
+  assert.ok(activityGuardStart > delayStart);
+  assert.ok(estimateStart > activityGuardStart);
+  assert.ok(componentStart > estimateStart);
+});
+
+test("getRecentSessions prefers cwd basename from session header", () => {
+  withTemporaryHome((home) => {
+    const sessionsDir = join(home, ".selesai", "agent", "sessions", "--Users-nico-dev-encoded-name--");
+    mkdirSync(sessionsDir, { recursive: true });
+    writeFileSync(join(sessionsDir, "session.jsonl"), JSON.stringify({ cwd: "/Users/nico/dev/my-dashed-project" }) + "\n");
+
+    assert.equal(getRecentSessions(1)[0]?.name, "my-dashed-project");
+  });
+});
+
+test("getRecentSessions falls back to encoded directory when header cwd is unusable", () => {
+  withTemporaryHome((home) => {
+    const root = join(home, ".selesai", "agent", "sessions");
+    const cases = [
+      ["invalid-json", "not-json\n"],
+      ["missing-cwd", JSON.stringify({ type: "session" }) + "\n"],
+      ["non-string-cwd", JSON.stringify({ cwd: 123 }) + "\n"],
+    ];
+
+    for (const [name, content] of cases) {
+      const sessionsDir = join(root, `--Users-nico-dev-${name}--`);
+      mkdirSync(sessionsDir, { recursive: true });
+      writeFileSync(join(sessionsDir, "session.jsonl"), content);
+    }
+
+    const names = getRecentSessions(10).map((session) => session.name);
+    assert.ok(names.includes("json"));
+    assert.ok(names.includes("cwd"));
+  });
+});
+
+test("welcome discovery respects SELESAI_CODING_AGENT_DIR for agent-global files", () => {
+  withTemporaryHome((home) => {
+    const root = mkdtempSync(join(tmpdir(), "powerline-welcome-agent-dir-"));
+    const project = join(root, "project");
+    const agentDir = join(root, "agent-dir");
+    const originalCwd = process.cwd();
+
+    try {
+      process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+      mkdirSync(project, { recursive: true });
+      mkdirSync(join(agentDir, "extensions", "local-ext"), { recursive: true });
+      mkdirSync(join(agentDir, "skills", "skill-a"), { recursive: true });
+      mkdirSync(join(agentDir, "commands"), { recursive: true });
+      mkdirSync(join(home, ".selesai", "agent"), { recursive: true });
+      writeFileSync(join(agentDir, "AGENTS.md"), "# Agent instructions\n");
+      writeFileSync(join(agentDir, "extensions", "local-ext", "index.ts"), "export default {};\n");
+      writeFileSync(join(agentDir, "skills", "skill-a", "SKILL.md"), "# Skill\n");
+      writeFileSync(join(agentDir, "commands", "hello.md"), "hello\n");
+      writeFileSync(join(agentDir, "settings.json"), JSON.stringify({ packages: ["npm:pkg-one@1.0.0"] }));
+      writeFileSync(join(home, ".selesai", "agent", "AGENTS.md"), "# Should not count\n");
+      process.chdir(project);
+
+      assert.deepEqual(discoverLoadedCounts(), {
+        contextFiles: 1,
+        extensions: 2,
+        skills: 1,
+        promptTemplates: 1,
+      });
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+test("getRecentSessions reads custom agent sessions and existing legacy sessions", () => {
+  withTemporaryHome((home) => {
+    const root = mkdtempSync(join(tmpdir(), "powerline-welcome-sessions-"));
+    const agentDir = join(root, "agent-dir");
+
+    try {
+      process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+      const customSessionDir = join(agentDir, "sessions", "--custom--");
+      const legacySessionDir = join(home, ".selesai", "sessions", "--legacy--");
+      mkdirSync(customSessionDir, { recursive: true });
+      mkdirSync(legacySessionDir, { recursive: true });
+      writeFileSync(join(customSessionDir, "session.jsonl"), JSON.stringify({ cwd: "/tmp/custom-project" }) + "\n");
+      writeFileSync(join(legacySessionDir, "session.jsonl"), JSON.stringify({ cwd: "/tmp/legacy-project" }) + "\n");
+
+      const names = getRecentSessions(10).map((session) => session.name);
+      assert.ok(names.includes("custom-project"));
+      assert.ok(names.includes("legacy-project"));
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});