@tokentop/ttop 0.6.1 → 0.8.0

package/src/tui/contexts/AgentSessionContext.tsx

@@ -5,10 +5,17 @@ import {
   useCallback,
   useContext,
   useEffect,
+  useMemo,
   useRef,
   useState,
 } from "react";
-import { aggregateSessionUsage, deduplicateAggregates } from "@/agents/aggregator.ts";
+import {
+  aggregateSessionUsage,
+  deduplicateAggregates,
+  isCrossAgentShadow,
+  markCrossAgentShadows,
+  selectEffectiveSessions,
+} from "@/agents/aggregator.ts";
 import { priceSessions } from "@/agents/costing.ts";
 import type { AgentId, AgentInfo, AgentSessionAggregate } from "@/agents/types.ts";
 import { createPluginContext } from "@/plugins/plugin-context-factory.ts";
@@ -48,10 +55,12 @@ interface AgentSessionProviderProps {
  */
 function computeSessionFingerprint(sessions: AgentSessionAggregate[]): string {
   // Build a compact string from the fields that actually affect the UI.
-  // This is intentionally simple — no crypto hashing needed, just string comparison.
+  // Shadow bit is included so that flipping a session's dedup status
+  // (gaining or losing its cross-agent shadow mark) triggers a re-render.
   let fp = `${sessions.length}:`;
   for (const s of sessions) {
-    fp += `${s.sessionId},${s.status},${s.lastActivityAt},${s.totals.input},${s.totals.output},${s.totalCostUsd ?? 0},${s.requestCount};`;
+    const shadow = isCrossAgentShadow(s) ? "1" : "0";
+    fp += `${s.sessionId},${s.status},${s.lastActivityAt},${s.totals.input},${s.totals.output},${s.totalCostUsd ?? 0},${s.requestCount},${shadow};`;
   }
   return fp;
 }
@@ -68,6 +77,9 @@ export function AgentSessionProvider({ children, autoRefresh = false }: AgentSes
   const { windowMs } = useTimeWindow();
   const hasBackfilled = useRef(false);
   const isRefreshingRef = useRef(false);
+  // Bugfix: track first completed load separately so an empty 1h window does not
+  // keep re-entering the initial loading state forever.
+  const hasLoadedOnceRef = useRef(false);
   const lastFingerprintRef = useRef<string>("");
 
   const discoverAgents = useCallback(async (): Promise<AgentInfo[]> => {
@@ -110,7 +122,17 @@ export function AgentSessionProvider({ children, autoRefresh = false }: AgentSes
 
       const http = createSandboxedHttpClient(plugin.id, plugin.permissions);
       const logger = createPluginLogger(plugin.id);
-      const ctx = { http, logger, config: {}, signal: AbortSignal.timeout(60_000) };
+      // Lazy signal: only create the 120s timer if the plugin actually reads ctx.signal.
+      let parseSignal: AbortSignal | undefined;
+      const ctx = {
+        http,
+        logger,
+        config: {},
+        get signal(): AbortSignal {
+          if (!parseSignal) parseSignal = AbortSignal.timeout(120_000);
+          return parseSignal;
+        },
+      };
 
       const rawSessions = await plugin.parseSessions(options, ctx);
 
@@ -134,7 +156,7 @@ export function AgentSessionProvider({ children, autoRefresh = false }: AgentSes
       if (isRefreshingRef.current) return;
       isRefreshingRef.current = true;
 
-      const isInitialLoad = sessions.length === 0;
+      const isInitialLoad = !hasLoadedOnceRef.current;
       if (isInitialLoad) {
         setIsLoading(true);
       }
@@ -193,7 +215,6 @@ export function AgentSessionProvider({ children, autoRefresh = false }: AgentSes
           }
         }
 
-        // Deduplicate sessions claimed by multiple agents scanning the same directory.
         const dedupedAggregates = deduplicateAggregates(allAggregates);
         if (dedupedAggregates.length < allAggregates.length) {
           debug(
@@ -203,6 +224,8 @@ export function AgentSessionProvider({ children, autoRefresh = false }: AgentSes
           );
         }
 
+        markCrossAgentShadows(dedupedAggregates);
+
         const pricedSessions = await priceSessions(dedupedAggregates);
 
         pricedSessions.sort((a, b) => b.lastActivityAt - a.lastActivityAt);
@@ -221,11 +244,13 @@ export function AgentSessionProvider({ children, autoRefresh = false }: AgentSes
           return;
         }
 
+        const effectiveSessions = selectEffectiveSessions(pricedSessions);
+
         // Persist to storage — the persistence service handles throttling
         // internally (fingerprint gate + 5-minute per-session throttle).
         // Safe to call every tick; state lives on globalThis, survives HMR.
         const now = Date.now();
-        const persistData = pricedSessions.map((session) => ({
+        const persistData = effectiveSessions.map((session) => ({
           session: {
             agentId: session.agentId,
             sessionId: session.sessionId,
@@ -258,7 +283,7 @@ export function AgentSessionProvider({ children, autoRefresh = false }: AgentSes
         }));
         const persistedCount = persistSessions(persistData);
         debug(
-          `Persisted ${persistedCount}/${pricedSessions.length} sessions to storage`,
+          `Persisted ${persistedCount}/${effectiveSessions.length} sessions to storage`,
           undefined,
           "agent-sessions",
         );
@@ -266,7 +291,11 @@ export function AgentSessionProvider({ children, autoRefresh = false }: AgentSes
         setSessions(pricedSessions);
         setLastRefreshAt(Date.now());
 
-        debug(`Session refresh complete`, { count: pricedSessions.length }, "agent-sessions");
+        debug(
+          `Session refresh complete`,
+          { count: pricedSessions.length, effective: effectiveSessions.length },
+          "agent-sessions",
+        );
       } catch (err) {
         const errorMsg = err instanceof Error ? err.message : "Unknown error";
         logError(`Session refresh failed: ${errorMsg}`, undefined, "agent-sessions");
@@ -275,15 +304,19 @@ export function AgentSessionProvider({ children, autoRefresh = false }: AgentSes
         isRefreshingRef.current = false;
         if (isInitialLoad) {
           setIsLoading(false);
+          hasLoadedOnceRef.current = true;
         }
       }
     },
-    [sessions.length, discoverAgents, fetchAgentSessions, debug, warn, logError, demoMode],
+    [discoverAgents, fetchAgentSessions, debug, warn, logError, demoMode, simulator],
   );
 
   const refreshSessionsRef = useRef(refreshSessions);
   refreshSessionsRef.current = refreshSessions;
 
+  const sessionsRef = useRef(sessions);
+  sessionsRef.current = sessions;
+
   useEffect(() => {
     if (!(demoMode || pluginsInitialized)) return;
 
@@ -304,7 +337,7 @@ export function AgentSessionProvider({ children, autoRefresh = false }: AgentSes
     let timerId: ReturnType<typeof setTimeout> | null = null;
 
     const scheduleNext = () => {
-      const hasActive = sessions.some((s) => s.status === "active");
+      const hasActive = sessionsRef.current.some((s) => s.status === "active");
       const interval = hasActive ? ACTIVE_INTERVAL_MS : IDLE_INTERVAL_MS;
 
       timerId = setTimeout(() => {
@@ -324,16 +357,21 @@ export function AgentSessionProvider({ children, autoRefresh = false }: AgentSes
         clearTimeout(timerId);
       }
     };
-  }, [autoRefresh, sessions, debug]);
-
-  const value: AgentSessionContextValue = {
-    sessions,
-    agents,
-    isLoading,
-    lastRefreshAt,
-    error,
-    refreshSessions,
-  };
+  }, [autoRefresh, debug]);
+
+  const effectiveSessions = useMemo(() => selectEffectiveSessions(sessions), [sessions]);
+
+  const value: AgentSessionContextValue = useMemo(
+    () => ({
+      sessions: effectiveSessions,
+      agents,
+      isLoading,
+      lastRefreshAt,
+      error,
+      refreshSessions,
+    }),
+    [effectiveSessions, agents, isLoading, lastRefreshAt, error, refreshSessions],
+  );
 
   return <AgentSessionContext.Provider value={value}>{children}</AgentSessionContext.Provider>;
 }

package/src/tui/contexts/PluginContext.tsx

@@ -275,7 +275,11 @@ export function PluginProvider({ children, cliPlugins }: PluginProviderProps) {
         return;
       }
 
-      // Skip providers that are currently rate-limited (backoff)
+      if (state.loading) {
+        debug(`Skipping refresh for ${providerId}: already in flight`, undefined, "refresh");
+        return;
+      }
+
       const now = Date.now();
       if (state.rateLimitUntil > now) {
         const remainingSec = Math.round((state.rateLimitUntil - now) / 1000);
@@ -360,19 +364,25 @@ export function PluginProvider({ children, cliPlugins }: PluginProviderProps) {
 
         const http = createSandboxedHttpClient(providerId, state.plugin.permissions);
         const logger = createPluginLogger(providerId);
+        // Lazy signal: only create the 30s timer if a plugin actually reads ctx.signal.
+        let fetchSignal: AbortSignal | undefined;
+        const fetchCtx = {
+          credentials: creds,
+          http,
+          logger,
+          config: {},
+          get signal(): AbortSignal {
+            if (!fetchSignal) fetchSignal = AbortSignal.timeout(30_000);
+            return fetchSignal;
+          },
+        };
 
         const fetchResult = await safeInvoke(
           providerId,
           "fetchUsage",
           () =>
             runInPluginGuard(providerId, state.plugin.permissions, () =>
-              state.plugin.fetchUsage({
-                credentials: creds,
-                http,
-                logger,
-                config: {},
-                signal: AbortSignal.timeout(30_000),
-              }),
+              state.plugin.fetchUsage(fetchCtx),
             ),
           {
             // Count non-rate-limit errors as circuit breaker failures.
@@ -513,14 +523,25 @@ export function PluginProvider({ children, cliPlugins }: PluginProviderProps) {
     await Promise.all(configuredProviders.map(refreshProvider));
   }, [providers, refreshProvider, info]);
 
+  const refreshProviderRef = useRef(refreshProvider);
+  const refreshAllProvidersRef = useRef(refreshAllProviders);
+  refreshProviderRef.current = refreshProvider;
+  refreshAllProvidersRef.current = refreshAllProviders;
+
+  const stableRefreshProvider = useCallback(
+    (providerId: string) => refreshProviderRef.current(providerId),
+    [],
+  );
+  const stableRefreshAllProviders = useCallback(() => refreshAllProvidersRef.current(), []);
+
   const value: PluginContextValue = {
     providers,
     agents,
     themes,
     notifications,
     isInitialized,
-    refreshProvider,
-    refreshAllProviders,
+    refreshProvider: stableRefreshProvider,
+    refreshAllProviders: stableRefreshAllProviders,
   };
 
   return <PluginContext.Provider value={value}>{children}</PluginContext.Provider>;

package/src/tui/utils/scrollFollow.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test";
+import { computeScrollOffset } from "./scrollFollow.ts";
+
+describe("computeScrollOffset", () => {
+  test("cursor inside viewport leaves offset unchanged", () => {
+    expect(computeScrollOffset(5, 0, 10, 100)).toBe(0);
+  });
+
+  test("cursor at bottom edge leaves offset unchanged", () => {
+    expect(computeScrollOffset(9, 0, 10, 100)).toBe(0);
+  });
+
+  test("cursor past bottom pulls offset down by one row", () => {
+    expect(computeScrollOffset(10, 0, 10, 100)).toBe(1);
+  });
+
+  test("cursor past top pulls offset up", () => {
+    expect(computeScrollOffset(3, 5, 10, 100)).toBe(3);
+  });
+
+  test("clamps offset to non-negative", () => {
+    expect(computeScrollOffset(0, 0, 10, 100)).toBe(0);
+  });
+
+  test("clamps offset to total - visibleRows", () => {
+    expect(computeScrollOffset(99, 0, 10, 100)).toBe(90);
+  });
+
+  test("offset stays 0 when content fits in viewport", () => {
+    expect(computeScrollOffset(3, 0, 10, 4)).toBe(0);
+  });
+
+  // Regression test for cursor-disappears-then-jump bug: rapid j presses
+  // that React batches into a single render must still land with the cursor
+  // visible at the bottom edge. Simulating N sequential functional updates
+  // (the reducer runs each one in order) verifies the invariant.
+  test("batched rapid j-presses keep cursor at bottom edge each step", () => {
+    const vis = 10;
+    const total = 1000;
+    let state = { row: 0, offset: 0 };
+    for (let i = 0; i < 50; i++) {
+      const nextRow = Math.min(state.row + 1, total - 1);
+      const nextOffset = computeScrollOffset(nextRow, state.offset, vis, total);
+      state = { row: nextRow, offset: nextOffset };
+      expect(state.row).toBeGreaterThanOrEqual(state.offset);
+      expect(state.row).toBeLessThan(state.offset + vis);
+    }
+    expect(state.row).toBe(50);
+    expect(state.offset).toBe(41);
+  });
+
+  test("batched rapid k-presses at top keep cursor at top edge", () => {
+    const vis = 10;
+    const total = 1000;
+    let state = { row: 50, offset: 41 };
+    for (let i = 0; i < 50; i++) {
+      const nextRow = Math.max(state.row - 1, 0);
+      const nextOffset = computeScrollOffset(nextRow, state.offset, vis, total);
+      state = { row: nextRow, offset: nextOffset };
+      expect(state.row).toBeGreaterThanOrEqual(state.offset);
+      expect(state.row).toBeLessThan(state.offset + vis);
+    }
+    expect(state.row).toBe(0);
+    expect(state.offset).toBe(0);
+  });
+
+  test("re-clamp when list shrinks below current offset", () => {
+    expect(computeScrollOffset(5, 50, 10, 20)).toBe(5);
+    expect(computeScrollOffset(19, 50, 10, 20)).toBe(10);
+  });
+});

package/src/tui/utils/scrollFollow.ts

@@ -0,0 +1,12 @@
+export function computeScrollOffset(
+  row: number,
+  prevOffset: number,
+  visibleRows: number,
+  total: number,
+): number {
+  let next = prevOffset;
+  if (row < next) next = row;
+  else if (row >= next + visibleRows) next = row - visibleRows + 1;
+  const max = Math.max(0, total - visibleRows);
+  return Math.max(0, Math.min(next, max));
+}

package/src/tui/views/Dashboard.tsx

@@ -60,12 +60,6 @@ export function Dashboard() {
   const cardRefs = useRef<(BoxRenderable | null)[]>([]);
   const inputRef = useRef<InputRenderable>(null);
 
-  useEffect(() => {
-    if (isInitialized) {
-      refreshAllProviders();
-    }
-  }, [isInitialized]);
-
   const getMaxUsage = useCallback((state: ProviderState) => {
     if (!state.usage?.limits) return 0;
 

package/src/tui/views/RealTimeDashboard.tsx

@@ -1,6 +1,15 @@
 import type { ScrollBoxRenderable } from "@opentui/core";
 import { useTerminalDimensions } from "@opentui/react";
-import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import {
+  type Dispatch,
+  type SetStateAction,
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import { notificationBus } from "@/plugins/notification-bus.ts";
 import { classifyProviderError } from "@/utils/error-category.ts";
 import { HelpOverlay } from "../components/HelpOverlay.tsx";
@@ -20,6 +29,7 @@ import { useDashboardKeyboard } from "../hooks/useDashboardKeyboard.ts";
 import type { SortDirection, SortField } from "../types/sort.ts";
 import { SORT_FIELDS } from "../types/sort.ts";
 import { getProviderColor } from "../utils/providerColor.ts";
+import { computeScrollOffset } from "../utils/scrollFollow.ts";
 
 export function RealTimeDashboard() {
   const colors = useColors();
@@ -77,7 +87,13 @@ export function RealTimeDashboard() {
   const { showDrawer, isOpen: showSessionDrawer } = useDrawer();
 
   const [showHelp, setShowHelp] = useState(false);
-  const [selectedRow, setSelectedRow] = useState(0);
+  // Cursor and scroll offset share one state so batched j-presses advance
+  // both in lockstep — see setSelectedRow below.
+  const [nav, setNav] = useState<{ selectedRow: number; scrollOffset: number }>({
+    selectedRow: 0,
+    scrollOffset: 0,
+  });
+  const { selectedRow, scrollOffset } = nav;
   const [focusedPanel, setFocusedPanel] = useState<"sessions" | "sidebar" | "limits">("sessions");
   const [sidebarCollapsed, setSidebarCollapsed] = useState(config.display.sidebarCollapsed);
   const [filterQuery, setFilterQuery] = useState("");
@@ -86,12 +102,7 @@ export function RealTimeDashboard() {
   const [sortDirection, setSortDirection] = useState<SortDirection>("desc");
   const [showSortOverlay, setShowSortOverlay] = useState(false);
   const [pendingG, setPendingG] = useState(false);
-  const scrollOffsetRef = useRef(0);
   const selectedSessionIdRef = useRef<string | null>(null);
-  const setScrollOffset = useCallback((val: number) => {
-    scrollOffsetRef.current = val;
-    sessionsScrollboxRef.current?.scrollTo(val);
-  }, []);
   const [limitSelectedIndex, setLimitSelectedIndex] = useState(0);
   const [driverDimension, setDriverDimension] = useState<DriverDimension>("model");
   const [selectedDriverIndex, setSelectedDriverIndex] = useState(0);
@@ -102,6 +113,32 @@ export function RealTimeDashboard() {
 
   const sessionsScrollboxRef = useRef<ScrollBoxRenderable>(null);
 
+  const visibleRowsRef = useRef(visibleRows);
+  visibleRowsRef.current = visibleRows;
+  const sessionsLengthRef = useRef(0);
+
+  const setSelectedRow = useCallback<Dispatch<SetStateAction<number>>>((arg) => {
+    setNav((prev) => {
+      const next = typeof arg === "function" ? arg(prev.selectedRow) : arg;
+      const clamped = Math.max(0, next);
+      const newOffset = computeScrollOffset(
+        clamped,
+        prev.scrollOffset,
+        visibleRowsRef.current,
+        sessionsLengthRef.current,
+      );
+      if (clamped === prev.selectedRow && newOffset === prev.scrollOffset) return prev;
+      return { selectedRow: clamped, scrollOffset: newOffset };
+    });
+  }, []);
+
+  const setScrollOffset = useCallback((val: number) => {
+    setNav((prev) => {
+      if (val === prev.scrollOffset) return prev;
+      return { ...prev, scrollOffset: val };
+    });
+  }, []);
+
   const configuredProviders = useMemo(() => {
     return Array.from(providers.values())
       .filter((p) => p.configured)
@@ -123,7 +160,9 @@ export function RealTimeDashboard() {
   );
 
   const baseFilteredSessions = useMemo(() => {
-    let result = [...agentSessions];
+    if (windowMs === null && !filterQuery) return agentSessions;
+
+    let result = agentSessions;
 
     if (windowMs !== null) {
       const cutoff = Date.now() - windowMs;
@@ -255,8 +294,12 @@ export function RealTimeDashboard() {
     return result;
   }, [baseFilteredSessions, activeDriverFilter, driverDimension, sortField, sortDirection]);
 
-  // Stabilize selection across re-sorts: track selected session by ID
-  // so the highlight follows the same session when live data causes reordering.
+  sessionsLengthRef.current = processedSessions.length;
+
+  // A keypress and a refresh tick can batch into one render; if they do,
+  // `prev` may be the user's new row while `selectedSessionIdRef` is still
+  // the session they moved *from*. Trusting `prev` when it resolves to a
+  // valid session prevents a snap-back bounce.
   useLayoutEffect(() => {
     if (processedSessions.length === 0) {
       setSelectedRow(0);
@@ -265,24 +308,40 @@ export function RealTimeDashboard() {
       return;
     }
 
-    if (selectedSessionIdRef.current) {
-      const newIndex = processedSessions.findIndex(
-        (s) => s.sessionId === selectedSessionIdRef.current,
-      );
-      if (newIndex !== -1) {
-        setSelectedRow(newIndex);
-        return;
+    setSelectedRow((prev) => {
+      const currentSession = processedSessions[prev];
+
+      if (currentSession) {
+        if (currentSession.sessionId === selectedSessionIdRef.current) {
+          return prev;
+        }
+        if (selectedSessionIdRef.current) {
+          const trackedIndex = processedSessions.findIndex(
+            (s) => s.sessionId === selectedSessionIdRef.current,
+          );
+          if (trackedIndex !== -1 && trackedIndex !== prev) {
+            return trackedIndex;
+          }
+        }
+        selectedSessionIdRef.current = currentSession.sessionId;
+        return prev;
+      }
+
+      if (selectedSessionIdRef.current) {
+        const trackedIndex = processedSessions.findIndex(
+          (s) => s.sessionId === selectedSessionIdRef.current,
+        );
+        if (trackedIndex !== -1) return trackedIndex;
+        selectedSessionIdRef.current = null;
       }
-      // Tracked session was filtered out — fall through to clamp
-      selectedSessionIdRef.current = null;
-    }
 
-    // Clamp to valid range (functional update avoids selectedRow in deps)
-    setSelectedRow((prev) => Math.min(prev, processedSessions.length - 1));
+      const clamped = Math.min(prev, processedSessions.length - 1);
+      selectedSessionIdRef.current = processedSessions[clamped]?.sessionId ?? null;
+      return clamped;
+    });
   }, [processedSessions, setScrollOffset]);
 
-  // Record which session the user selected (runs after navigation and stabilization)
-  useEffect(() => {
+  useLayoutEffect(() => {
     const session = processedSessions[selectedRow];
     if (session) {
       selectedSessionIdRef.current = session.sessionId;
@@ -290,19 +349,22 @@ export function RealTimeDashboard() {
   }, [selectedRow, processedSessions]);
 
   useLayoutEffect(() => {
-    if (!sessionsScrollboxRef.current || processedSessions.length === 0) return;
-
-    let newOffset = scrollOffsetRef.current;
-
-    if (selectedRow < newOffset) {
-      newOffset = selectedRow;
-    } else if (selectedRow >= newOffset + visibleRows) {
-      newOffset = selectedRow - visibleRows + 1;
-    }
+    if (processedSessions.length === 0) return;
+    setNav((prev) => {
+      const newOffset = computeScrollOffset(
+        prev.selectedRow,
+        prev.scrollOffset,
+        visibleRows,
+        processedSessions.length,
+      );
+      if (newOffset === prev.scrollOffset) return prev;
+      return { ...prev, scrollOffset: newOffset };
+    });
+  }, [processedSessions.length, visibleRows]);
 
-    scrollOffsetRef.current = newOffset;
-    sessionsScrollboxRef.current.scrollTo(newOffset);
-  }, [selectedRow, processedSessions.length, visibleRows]);
+  useLayoutEffect(() => {
+    sessionsScrollboxRef.current?.scrollTo(scrollOffset);
+  }, [scrollOffset]);
 
   const openSessionDrawer = useCallback(() => {
     const session = processedSessions[selectedRow];
@@ -325,7 +387,7 @@ export function RealTimeDashboard() {
       sortField,
       sortDirection,
       pendingG,
-      scrollOffset: scrollOffsetRef.current,
+      scrollOffset,
       limitSelectedIndex,
       providerCount: configuredProviders.length,
       driverDimension,
@@ -409,7 +471,10 @@ export function RealTimeDashboard() {
     }
   };
 
-  const activeCount = agentSessions.filter((s) => s.status === "active").length;
+  const activeCount = useMemo(
+    () => agentSessions.reduce((n, s) => (s.status === "active" ? n + 1 : n), 0),
+    [agentSessions],
+  );
 
   return (
     <box flexDirection="column" flexGrow={1} padding={1} gap={1} overflow="hidden">
@@ -491,6 +556,8 @@ export function RealTimeDashboard() {
           ref={sessionsScrollboxRef}
           sessions={processedSessions}
           selectedRow={selectedRow}
+          scrollOffset={scrollOffset}
+          visibleRows={visibleRows}
           isLoading={isLoading}
           isFiltering={isFiltering}
           filterQuery={filterQuery}

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.6.1"; // x-release-please-version
+export const VERSION = "0.8.0"; // x-release-please-version

package/tsconfig.json

@@ -0,0 +1,43 @@
+{
+  "compilerOptions": {
+    // Environment setup
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+
+    // OpenTUI React JSX configuration
+    "jsx": "react-jsx",
+    "jsxImportSource": "@opentui/react",
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "allowJs": true,
+
+    // Strict mode
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Path mapping
+    "paths": {
+      "@/*": ["./src/*"],
+      "@plugins/*": ["./src/plugins/*"],
+      "@tui/*": ["./src/tui/*"],
+      "@utils/*": ["./src/utils/*"]
+    },
+
+    // Additional checks
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "exactOptionalPropertyTypes": true,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": ["src/**/*", "templates/**/*"],
+  "exclude": ["dist", "node_modules"]
+}