@selesai/code 0.7.0 → 0.8.0

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

@@ -0,0 +1,304 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+
+type SessionAssistantUsage = AssistantMessage["usage"];
+
+export interface SessionTokenStats {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+  subagentCost: number;
+  lastAssistant: AssistantMessage | undefined;
+  thinkingLevelFromSession: string | null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function hasSessionAssistantUsage(value: unknown): value is SessionAssistantUsage {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  if (
+    typeof value.input !== "number" ||
+    typeof value.output !== "number" ||
+    typeof value.cacheRead !== "number" ||
+    typeof value.cacheWrite !== "number"
+  ) {
+    return false;
+  }
+
+  return isRecord(value.cost) && typeof value.cost.total === "number";
+}
+
+function isSessionAssistantMessage(value: unknown): value is AssistantMessage {
+  return isRecord(value)
+    && value.role === "assistant"
+    && hasSessionAssistantUsage(value.usage)
+    && (value.stopReason === undefined || typeof value.stopReason === "string");
+}
+
+function getUsageTokenTotal(usage: SessionAssistantUsage): number {
+  const totalTokens = "totalTokens" in usage && typeof usage.totalTokens === "number" ? usage.totalTokens : 0;
+  return totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+
+// Matches pi-subagents' internal SLASH_RESULT_TYPE custom_message marker.
+const SUBAGENT_SLASH_RESULT_TYPE = "subagent-slash-result";
+
+function subagentDetailsFromSessionEntry(e: Record<string, unknown>): { results: unknown[] } | undefined {
+  if (e.type === "custom_message" && e.customType === SUBAGENT_SLASH_RESULT_TYPE) {
+    const details = isRecord(e.details) ? e.details : undefined;
+    const result = isRecord(details?.result) ? details.result : undefined;
+    const inner = isRecord(result?.details) ? result.details : undefined;
+    return Array.isArray(inner?.results) ? { results: inner.results } : undefined;
+  }
+  if (e.type === "message" && isRecord(e.message)) {
+    const message = e.message as { role?: unknown; toolName?: unknown; details?: unknown };
+    if (message.role === "toolResult" && message.toolName === "subagent" && isRecord(message.details) && Array.isArray(message.details.results)) {
+      return { results: message.details.results };
+    }
+  }
+  return undefined;
+}
+
+// Sums subagent child usage cost recorded on a single session entry (parallel/chain/single runs
+// launched via the subagent tool or /parallel, /worker etc. slash commands), so the footer can
+// show total spend rather than only the interactive parent session's cost.
+function extractSubagentResultCost(e: Record<string, unknown>): number {
+  const details = subagentDetailsFromSessionEntry(e);
+  if (!details) return 0;
+  let total = 0;
+  for (const result of details.results) {
+    if (!isRecord(result)) continue;
+    const usage = isRecord(result.usage) ? result.usage : undefined;
+    if (typeof usage?.cost === "number") total += usage.cost;
+  }
+  return total;
+}
+
+/**
+ * Fingerprint of the fields on a session event that influence the aggregated
+ * stats. Comparing only the event count is not enough: while streaming, pi
+ * may update the trailing assistant message in place (usage grows, stopReason
+ * flips), so the same event reference can carry fresh numbers.
+ */
+function eventStatsSignature(event: unknown): string {
+  if (!isRecord(event)) {
+    return "?";
+  }
+
+  if (event.type === "thinking_level_change") {
+    return `t:${typeof event.thinkingLevel === "string" ? event.thinkingLevel : ""}`;
+  }
+
+  const subagentDetails = subagentDetailsFromSessionEntry(event);
+  if (subagentDetails) {
+    return `s:${subagentDetails.results.length}:${extractSubagentResultCost(event)}`;
+  }
+
+  if (event.type === "message" && isRecord(event.message)) {
+    const message = event.message;
+    const role = typeof message.role === "string" ? message.role : "";
+    const stopReason = typeof message.stopReason === "string" ? message.stopReason : "";
+    if (role === "assistant" && hasSessionAssistantUsage(message.usage)) {
+      const usage = message.usage;
+      return `a:${stopReason}:${usage.input}/${usage.output}/${usage.cacheRead}/${usage.cacheWrite}/${usage.cost.total}`;
+    }
+    return `m:${role}:${stopReason}`;
+  }
+
+  return `e:${typeof event.type === "string" ? event.type : "?"}`;
+}
+
+function emptySessionTokenStats(): SessionTokenStats {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    cost: 0,
+    subagentCost: 0,
+    lastAssistant: undefined,
+    thinkingLevelFromSession: null,
+  };
+}
+
+function copySessionTokenStats(stats: SessionTokenStats): SessionTokenStats {
+  return { ...stats };
+}
+
+function accumulateSessionEvent(stats: SessionTokenStats, event: unknown): void {
+  if (!isRecord(event)) return;
+
+  if (event.type === "thinking_level_change" && typeof event.thinkingLevel === "string") {
+    stats.thinkingLevelFromSession = event.thinkingLevel;
+  }
+
+  stats.subagentCost += extractSubagentResultCost(event);
+
+  if (event.type !== "message" || !isSessionAssistantMessage(event.message)) return;
+
+  const message = event.message;
+  if (message.stopReason === "error" || message.stopReason === "aborted") return;
+
+  stats.input += message.usage.input;
+  stats.output += message.usage.output;
+  stats.cacheRead += message.usage.cacheRead;
+  stats.cacheWrite += message.usage.cacheWrite;
+  stats.cost += message.usage.cost.total;
+  if (getUsageTokenTotal(message.usage) > 0) {
+    stats.lastAssistant = message;
+  }
+}
+
+export interface SessionBranchProvider {
+  getLeafId(): string | null;
+  getBranch(): readonly unknown[];
+}
+
+function isSessionBranchProvider(value: unknown): value is SessionBranchProvider {
+  return isRecord(value) && typeof value.getLeafId === "function" && typeof value.getBranch === "function";
+}
+
+/**
+ * Session branches are immutable for a given leaf. Keep the already-built path
+ * while streaming updates mutate only its trailing message in place.
+ */
+export class SessionBranchCache {
+  private provider: SessionBranchProvider | null = null;
+  private leafId: string | null = null;
+  private branch: readonly unknown[] = [];
+
+  get(source: unknown): readonly unknown[] {
+    if (!isSessionBranchProvider(source)) return [];
+
+    const provider = source;
+    const leafId = provider.getLeafId();
+    // A reset cache holds provider === null, which never matches a live provider.
+    if (this.provider !== provider || this.leafId !== leafId) {
+      this.provider = provider;
+      this.leafId = leafId;
+      this.branch = provider.getBranch();
+    }
+    return this.branch;
+  }
+
+  reset(): void {
+    this.provider = null;
+    this.leafId = null;
+    this.branch = [];
+  }
+}
+
+export function computeSessionTokenStats(sessionEvents: readonly unknown[]): SessionTokenStats {
+  let input = 0, output = 0, cacheRead = 0, cacheWrite = 0, cost = 0, subagentCost = 0;
+  let lastAssistant: AssistantMessage | undefined;
+  let thinkingLevelFromSession: string | null = null;
+
+  for (const e of sessionEvents) {
+    if (!isRecord(e)) continue;
+
+    if (e.type === "thinking_level_change" && typeof e.thinkingLevel === "string") {
+      thinkingLevelFromSession = e.thinkingLevel;
+    }
+
+    subagentCost += extractSubagentResultCost(e);
+
+    if (e.type !== "message" || !isSessionAssistantMessage(e.message)) continue;
+
+    const m = e.message;
+    if (m.stopReason === "error" || m.stopReason === "aborted") continue;
+
+    input += m.usage.input;
+    output += m.usage.output;
+    cacheRead += m.usage.cacheRead;
+    cacheWrite += m.usage.cacheWrite;
+    cost += m.usage.cost.total;
+    if (getUsageTokenTotal(m.usage) > 0) {
+      lastAssistant = m;
+    }
+  }
+
+  return { input, output, cacheRead, cacheWrite, cost, subagentCost, lastAssistant, thinkingLevelFromSession };
+}
+
+/**
+ * Cache for token counting: avoid re-scanning the full session event list on
+ * every render (250ms-1s cadence while streaming). Historical session entries
+ * are append-only, so appended entries are accumulated and an in-place update
+ * to the trailing streaming entry only recomputes that entry.
+ */
+export class SessionTokenStatsCache {
+  private eventCount = -1;
+  private lastEvent: unknown;
+  private lastSignature = "";
+  private prefixStats: SessionTokenStats | null = null;
+  private stats: SessionTokenStats | null = null;
+
+  get(sessionEvents: readonly unknown[]): SessionTokenStats {
+    const eventCount = sessionEvents.length;
+    const lastEvent = eventCount > 0 ? sessionEvents[eventCount - 1] : undefined;
+    const lastSignature = eventStatsSignature(lastEvent);
+
+    if (
+      this.stats !== null
+      && this.eventCount === eventCount
+      && this.lastEvent === lastEvent
+      && this.lastSignature === lastSignature
+    ) {
+      return this.stats;
+    }
+
+    // getBranch() walks unique parent links, so an identical trailing event at
+    // the previous count proves the whole previous array is an unchanged prefix.
+    const previousStats = this.stats;
+    const canExtendPreviousStats = previousStats !== null
+      && eventCount > this.eventCount
+      && (this.eventCount === 0 || (
+        sessionEvents[this.eventCount - 1] === this.lastEvent
+        && eventStatsSignature(sessionEvents[this.eventCount - 1]) === this.lastSignature
+      ));
+
+    let prefixStats: SessionTokenStats;
+    if (canExtendPreviousStats && previousStats !== null) {
+      prefixStats = copySessionTokenStats(previousStats);
+      for (let index = this.eventCount; index < eventCount - 1; index += 1) {
+        accumulateSessionEvent(prefixStats, sessionEvents[index]);
+      }
+    } else if (
+      this.prefixStats !== null
+      && this.eventCount === eventCount
+      && this.lastEvent === lastEvent
+    ) {
+      // Same array with an in-place tail mutation: reuse the cached prefix.
+      prefixStats = this.prefixStats;
+    } else {
+      prefixStats = emptySessionTokenStats();
+      for (let index = 0; index < eventCount - 1; index += 1) {
+        accumulateSessionEvent(prefixStats, sessionEvents[index]);
+      }
+    }
+
+    const stats = copySessionTokenStats(prefixStats);
+    if (eventCount > 0) accumulateSessionEvent(stats, lastEvent);
+
+    this.eventCount = eventCount;
+    this.lastEvent = lastEvent;
+    this.lastSignature = lastSignature;
+    this.prefixStats = prefixStats;
+    this.stats = stats;
+    return stats;
+  }
+
+  reset(): void {
+    this.eventCount = -1;
+    this.lastEvent = undefined;
+    this.lastSignature = "";
+    this.prefixStats = null;
+    this.stats = null;
+  }
+}

package/dist/extensions/pi-powerline-footer/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "types": ["node"],
+    "allowImportingTsExtensions": true
+  },
+  "include": ["*.ts", "bash-mode/**/*.ts", "fixed-editor/**/*.ts", "queue/**/*.ts"]
+}

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

@@ -1,4 +1,5 @@
 import type { Theme, ThemeColor } from "@selesai/code";
+import type { CostCurrencyCode } from "./currency-rates.ts";
 
 // Theme color - either a pi theme color name or a custom hex color
 export type ColorValue = ThemeColor | `#${string}`;
@@ -20,6 +21,7 @@ export type SemanticColor =
   | "contextError"
   | "cost"
   | "tokens"
+  | "queue"
   | "separator"
   | "border";
 
@@ -27,29 +29,30 @@ export type SemanticColor =
 export type ColorScheme = Partial<Record<SemanticColor, ColorValue>>;
 
 // Built-in segment identifiers
-export type BuiltinStatusLineSegmentId =
-  | "model"
-  | "identity_group"
-  | "shell_mode"
-  | "path"
-  | "git"
-  | "subagents"
-  | "token_in"
-  | "token_out"
-  | "token_total"
-  | "usage_group"
-  | "cost"
-  | "context_pct"
-  | "context_total"
-  | "time_spent"
-  | "time"
-  | "session"
-  | "session_name"
-  | "hostname"
-  | "cache_read"
-  | "cache_write"
-  | "thinking"
-  | "extension_statuses";
+export const BUILTIN_STATUS_LINE_SEGMENT_IDS = [
+  "model",
+  "shell_mode",
+  "path",
+  "git",
+  "subagents",
+  "queue",
+  "token_in",
+  "token_out",
+  "token_total",
+  "cost",
+  "context_pct",
+  "context_total",
+  "time_spent",
+  "time",
+  "session",
+  "hostname",
+  "cache_read",
+  "cache_write",
+  "thinking",
+  "extension_statuses",
+] as const;
+
+export type BuiltinStatusLineSegmentId = typeof BUILTIN_STATUS_LINE_SEGMENT_IDS[number];
 
 // Segment identifiers (built-in + dynamically registered custom items)
 export type StatusLineSegmentId = BuiltinStatusLineSegmentId | `custom:${string}`;
@@ -68,28 +71,47 @@ export type StatusLineSeparatorStyle =
   | "star";
 
 // Preset names
+export type PowerlinePlacement = "above" | "below";
+
 export type StatusLinePreset =
   | "default"
   | "minimal"
   | "compact"
   | "full"
   | "nerd"
-  | "ascii"
-  | "custom";
+  | "ascii";
 
 // Per-segment options
 export interface StatusLineSegmentOptions {
-  model?: { showThinkingLevel?: boolean };
+  model?: { showThinkingLevel?: boolean; display?: "name" | "qualified" };
   path?: {
     mode?: "basename" | "abbreviated" | "full";
     maxLength?: number;
   };
-  git?: { showBranch?: boolean; showStaged?: boolean; showUnstaged?: boolean; showUntracked?: boolean };
+  git?: {
+    showBranch?: boolean;
+    showStaged?: boolean;
+    showUnstaged?: boolean;
+    showUntracked?: boolean;
+    polling?: "full" | "branch" | "off";
+    /** Replace the branch icon with the origin remote's host logo
+     * (GitHub/GitLab/Bitbucket, or a generic git logo). Default false. */
+    hostIcon?: boolean;
+  };
   time?: { format?: "12h" | "24h"; showSeconds?: boolean };
+  cost?: { subscriptionDisplay?: "subscription" | "reported-cost" | "both"; currency?: CostCurrencyCode };
+  context?: { format?: "full" | "percent" };
+  cache_read?: { format?: "tokens" | "percent" | "both" };
 }
 
 export type CustomItemPosition = "left" | "right" | "secondary";
 
+export interface StatusLineLayout {
+  left?: StatusLineSegmentId[];
+  right?: StatusLineSegmentId[];
+  secondary?: StatusLineSegmentId[];
+}
+
 export interface CustomStatusItem {
   id: string;
   statusKey: string;
@@ -132,18 +154,38 @@ export interface GitStatus {
 }
 
 // Usage statistics
+export interface QueueSummary {
+  queueCount: number;
+  ideaCount: number;
+  blockedCount: number;
+  compacting: boolean;
+  leadingText: string | null;
+  leadingIntent: "steer" | "follow-up" | "post-compact" | "idea" | null;
+  leadingStatus: "queued" | "blocked" | "delivering" | "sent" | "failed" | null;
+}
+
 export interface UsageStats {
   input: number;
   output: number;
   cacheRead: number;
   cacheWrite: number;
   cost: number;
+  // Cumulative cost of subagent child runs (e.g. /parallel, /worker) launched from this session.
+  subagentCost: number;
 }
 
 // Context passed to segment render functions
 export interface SegmentContext {
   // From pi-mono
-  model: { id: string; name?: string; reasoning?: boolean; contextWindow?: number } | undefined;
+  model: {
+    id: string;
+    name?: string;
+    provider?: string;
+    providerId?: string;
+    providerName?: string;
+    reasoning?: boolean;
+    contextWindow?: number;
+  } | undefined;
   thinkingLevel: string;
   sessionId: string | undefined;
   sessionName: string | undefined;
@@ -151,11 +193,14 @@ export interface SegmentContext {
 
   // Computed
   usageStats: UsageStats;
-  contextPercent: number;
+  contextTokens: number | null;
+  contextPercent: number | null;
   contextWindow: number;
+  contextApproximate: boolean;
   autoCompactEnabled: boolean;
   customCompactionEnabled: boolean;
   usingSubscription: boolean;
+  queueSummary: QueueSummary;
   sessionStartTime: number;
   shellModeActive: boolean;
   shellRunning: boolean;

package/dist/extensions/pi-powerline-footer/welcome-dismiss.ts

@@ -0,0 +1,34 @@
+export interface WelcomeDismissScheduler<Context> {
+  schedule(ctx: Context): void;
+  cancel(): void;
+}
+
+interface WelcomeDismissSchedulerOptions<Context> {
+  dismiss(ctx: Context): void;
+  getGeneration(): number;
+  isEnabled(): boolean;
+}
+
+export function createWelcomeDismissScheduler<Context>(
+  options: WelcomeDismissSchedulerOptions<Context>,
+): WelcomeDismissScheduler<Context> {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  return {
+    schedule(ctx) {
+      if (timer) return;
+
+      const generation = options.getGeneration();
+      timer = setTimeout(() => {
+        timer = null;
+        if (!options.isEnabled() || generation !== options.getGeneration()) return;
+        options.dismiss(ctx);
+      }, 0);
+    },
+    cancel() {
+      if (!timer) return;
+      clearTimeout(timer);
+      timer = null;
+    },
+  };
+}

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

@@ -1,4 +1,4 @@
-import { readdirSync, existsSync, statSync, readFileSync } from "node:fs";
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
 import { join, basename } from "node:path";
 import { homedir as osHomedir } from "node:os";
 import { CONFIG_DIR_NAME, getAgentDir, getSettingsPath } from "@selesai/code";
@@ -19,6 +19,13 @@ export interface LoadedCounts {
   promptTemplates: number;
 }
 
+function formatTokens(tokens: number): string {
+  if (tokens < 1000) return tokens.toString();
+  if (tokens < 10000) return `${(tokens / 1000).toFixed(1)}k`;
+  if (tokens < 1000000) return `${Math.round(tokens / 1000)}k`;
+  return `${(tokens / 1000000).toFixed(tokens < 10000000 ? 1 : 0)}M`;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Shared rendering utilities
 // ═══════════════════════════════════════════════════════════════════════════
@@ -41,6 +48,7 @@ const GRADIENT_COLORS = [
   "\x1b[38;5;75m",
   "\x1b[38;5;51m",
 ];
+const SESSION_HEADER_READ_BYTES = 8192;
 
 function bold(text: string): string {
   return `\x1b[1m${text}\x1b[22m`;
@@ -97,6 +105,7 @@ interface WelcomeData {
   loadedCounts: LoadedCounts;
   guideMode: GuideMode;
   newFeatures: GuideFeature[];
+  initialContextTokens: number | null;
 }
 
 function buildLeftColumn(data: WelcomeData, colWidth: number): string[] {
@@ -172,6 +181,14 @@ function buildRightColumn(data: WelcomeData, colWidth: number): string[] {
     countLines.push(` ${dim("No extensions loaded")}`);
   }
 
+  if (
+    data.initialContextTokens !== null
+    && Number.isFinite(data.initialContextTokens)
+    && data.initialContextTokens > 0
+  ) {
+    countLines.push(` ${itemPrefix}${fgOnly("gitClean", `≈ ${formatTokens(data.initialContextTokens)}`)} initial prompt tokens`);
+  }
+
   const dashboardLines = data.guideMode === "full"
     ? []
     : [
@@ -182,7 +199,6 @@ function buildRightColumn(data: WelcomeData, colWidth: number): string[] {
       ` ${bold(fgOnly("accent", "Recent sessions"))}`,
       ...sessionLines,
     ];
-
   return [
     ` ${bold(fgOnly("accent", "Tips"))}: ${dim("/")} commands · ${dim("/settings")} configure`,
     ` ${dim("Shift+Tab")} cycle thinking`,
@@ -266,8 +282,9 @@ export class WelcomeComponent implements Component {
     loadedCounts: LoadedCounts = { contextFiles: 0, extensions: 0, skills: 0, promptTemplates: 0 },
     guideMode: GuideMode = "full",
     newFeatures: GuideFeature[] = [],
+    initialContextTokens: number | null = null,
   ) {
-    this.data = { modelName, providerName, recentSessions, loadedCounts, guideMode, newFeatures };
+    this.data = { modelName, providerName, recentSessions, loadedCounts, guideMode, newFeatures, initialContextTokens };
   }
 
   invalidate(): void {}
@@ -313,8 +330,9 @@ export class WelcomeHeader implements Component {
     loadedCounts: LoadedCounts = { contextFiles: 0, extensions: 0, skills: 0, promptTemplates: 0 },
     guideMode: GuideMode = "compact",
     newFeatures: GuideFeature[] = [],
+    initialContextTokens: number | null = null,
   ) {
-    this.data = { modelName, providerName, recentSessions, loadedCounts, guideMode, newFeatures };
+    this.data = { modelName, providerName, recentSessions, loadedCounts, guideMode, newFeatures, initialContextTokens };
   }
 
   invalidate(): void {}
@@ -352,6 +370,15 @@ export class WelcomeHeader implements Component {
 const loggedDiscoveryErrors = new Set<string>();
 
 function logDiscoveryError(scope: string, error: unknown): void {
+  if (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { code?: unknown }).code === "ENOENT"
+  ) {
+    return;
+  }
+
   const message = error instanceof Error ? error.message : String(error);
   const key = `${scope}:${message}`;
   if (loggedDiscoveryErrors.has(key)) {
@@ -578,6 +605,39 @@ export function discoverLoadedCounts(): LoadedCounts {
 /**
  * Get recent sessions from the sessions directory.
  */
+function readSessionHeaderProjectName(filePath: string): string | null {
+  let fd: number | null = null;
+  try {
+    fd = openSync(filePath, "r");
+    const buffer = Buffer.alloc(SESSION_HEADER_READ_BYTES);
+    const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
+    const firstLine = buffer.toString("utf8", 0, bytesRead).split(/\r?\n/, 1)[0]?.trim();
+    if (!firstLine) return null;
+
+    const header: unknown = JSON.parse(firstLine);
+    if (typeof header !== "object" || header === null || Array.isArray(header)) return null;
+
+    const cwd = Reflect.get(header, "cwd");
+    if (typeof cwd !== "string" || cwd.trim().length === 0) return null;
+
+    return basename(cwd) || cwd;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) closeSync(fd);
+  }
+}
+
+function sessionProjectNameFromDirectory(dir: string): string {
+  const parentName = basename(dir);
+  if (!parentName.startsWith("--")) {
+    return parentName;
+  }
+
+  const parts = parentName.split("-").filter(p => p);
+  return parts[parts.length - 1] || parentName;
+}
+
 export function getRecentSessions(maxCount: number = 3): RecentSession[] {
   const homeDir = getAgentDir();
   const home = homedirSafe();
@@ -600,12 +660,7 @@ export function getRecentSessions(maxCount: number = 3): RecentSession[] {
           if (stats.isDirectory()) {
             scanDir(entryPath);
           } else if (entry.endsWith(".jsonl")) {
-            const parentName = basename(dir);
-            let projectName = parentName;
-            if (parentName.startsWith("--")) {
-              const parts = parentName.split("-").filter(p => p);
-              projectName = parts[parts.length - 1] || parentName;
-            }
+            const projectName = readSessionHeaderProjectName(entryPath) ?? sessionProjectNameFromDirectory(dir);
             sessions.push({ name: projectName, mtime: stats.mtimeMs });
           }
         } catch (error) {