fleetlens 0.10.0 → 0.10.2

package/app/apps/web/app/api/ask/route.ts

@@ -18,6 +18,12 @@
 import { getSession } from "@claude-lens/parser/fs";
 import { summarizeSessionForAI } from "@/lib/ai/session-summary";
 import { spawn } from "node:child_process";
+import {
+  runClaudeUnderTmux,
+  tmuxRunnerAvailable,
+  TmuxRunError,
+  TmuxUnavailableError,
+} from "@claude-lens/entries/node";
 
 export const dynamic = "force-dynamic";
 export const runtime = "nodejs";
@@ -56,6 +62,11 @@ export async function POST(request: Request) {
   const fullPrompt = `Here is the session transcript summary:\n\n${context}\n\n---\n\nUser's question: ${question}`;
 
   const encoder = new TextEncoder();
+  // Resolve at request time so an admin toggling tmux on/off doesn't
+  // require a server restart.
+  const useTmux =
+    process.env.FLEETLENS_FORCE_PRINT_MODE !== "1" && tmuxRunnerAvailable().ok;
+
   const stream = new ReadableStream({
     start(controller) {
       let closed = false;
@@ -69,127 +80,129 @@ export async function POST(request: Request) {
         }
       }
 
-      // Resolve the claude binary — prefer the well-known location if it
-      // exists, otherwise fall back to PATH resolution. The user must have
-      // Claude Code installed and logged in.
-      const claudeBin = "claude";
-
-      const args = [
-        "-p", // print mode (non-interactive)
-        "--output-format",
-        "stream-json",
-        "--verbose",
-        "--model",
-        model,
-        "--tools",
-        "", // no tools — pure analysis
-        "--disable-slash-commands",
-        "--no-session-persistence",
-        "--setting-sources",
-        "", // skip user settings for speed
-        "--append-system-prompt",
-        SYSTEM_PROMPT,
-      ];
-
-      const proc = spawn(claudeBin, args, {
-        stdio: ["pipe", "pipe", "pipe"],
-        // Inherit PATH so the claude binary is found.
-        env: { ...process.env },
-      });
-
-      // Write the prompt to stdin and close.
-      proc.stdin.write(fullPrompt);
-      proc.stdin.end();
-
-      let stderr = "";
-
-      proc.stdout.on("data", (chunk: Buffer) => {
-        const text = chunk.toString("utf8");
-        // stream-json emits one JSON object per line.
-        for (const line of text.split("\n")) {
-          const trimmed = line.trim();
-          if (!trimmed) continue;
+      function finish() {
+        if (!closed) {
+          try { controller.close(); } catch {}
+          closed = true;
+        }
+      }
+
+      // Kick off the LLM work without awaiting — Next.js waits for start()
+      // to return before opening the response, so any blocking here would
+      // stall the SSE headers.
+      void (async () => {
+        if (useTmux) {
           try {
-            const obj = JSON.parse(trimmed) as Record<string, unknown>;
-
-            // We care about assistant message content blocks of type "text".
-            if (obj.type === "assistant") {
-              const msg = obj.message as Record<string, unknown> | undefined;
-              const content = msg?.content as Array<Record<string, unknown>> | undefined;
-              if (Array.isArray(content)) {
-                for (const block of content) {
-                  if (block.type === "text" && typeof block.text === "string") {
-                    send({ type: "delta", text: block.text });
+            const res = await runClaudeUnderTmux({
+              systemPrompt: SYSTEM_PROMPT,
+              model,
+              userPrompt: fullPrompt,
+              onDelta: (chunk) => send({ type: "delta", text: chunk }),
+              signal: request.signal,
+            });
+            send({ type: "done", totalTokens: res.input_tokens + res.output_tokens });
+            finish();
+            return;
+          } catch (err) {
+            const isExpected = err instanceof TmuxUnavailableError || err instanceof TmuxRunError;
+            if (!isExpected) {
+              console.warn("[ask] tmux runner failed, falling back to -p:", err);
+            }
+            // fall through to print mode
+          }
+        }
+        runPrintModeFallback();
+      })();
+
+      function runPrintModeFallback() {
+        const claudeBin = "claude";
+
+        const args = [
+          "-p",
+          "--output-format",
+          "stream-json",
+          "--verbose",
+          "--model",
+          model,
+          "--tools",
+          "",
+          "--disable-slash-commands",
+          "--no-session-persistence",
+          "--setting-sources",
+          "",
+          "--append-system-prompt",
+          SYSTEM_PROMPT,
+        ];
+
+        const proc = spawn(claudeBin, args, {
+          stdio: ["pipe", "pipe", "pipe"],
+          env: { ...process.env },
+        });
+
+        proc.stdin.write(fullPrompt);
+        proc.stdin.end();
+
+        let stderr = "";
+
+        proc.stdout.on("data", (chunk: Buffer) => {
+          const text = chunk.toString("utf8");
+          for (const line of text.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            try {
+              const obj = JSON.parse(trimmed) as Record<string, unknown>;
+              if (obj.type === "assistant") {
+                const msg = obj.message as Record<string, unknown> | undefined;
+                const content = msg?.content as Array<Record<string, unknown>> | undefined;
+                if (Array.isArray(content)) {
+                  for (const block of content) {
+                    if (block.type === "text" && typeof block.text === "string") {
+                      send({ type: "delta", text: block.text });
+                    }
                   }
                 }
               }
+              if (obj.type === "result") {
+                const usage = obj.usage as Record<string, unknown> | undefined;
+                const totalTokens =
+                  typeof usage?.input_tokens === "number" &&
+                  typeof usage?.output_tokens === "number"
+                    ? usage.input_tokens + usage.output_tokens
+                    : undefined;
+                send({ type: "done", totalTokens: totalTokens ?? undefined });
+              }
+            } catch {
+              // Skip non-JSON lines (verbose debug output, etc.)
             }
-
-            // Result event — extract total tokens for display.
-            if (obj.type === "result") {
-              const usage = obj.usage as Record<string, unknown> | undefined;
-              const totalTokens =
-                typeof usage?.input_tokens === "number" &&
-                typeof usage?.output_tokens === "number"
-                  ? usage.input_tokens + usage.output_tokens
-                  : undefined;
-              send({ type: "done", totalTokens: totalTokens ?? undefined });
-            }
-          } catch {
-            // Skip non-JSON lines (verbose debug output, etc.)
           }
-        }
-      });
-
-      proc.stderr.on("data", (chunk: Buffer) => {
-        stderr += chunk.toString("utf8");
-      });
-
-      proc.on("close", (code) => {
-        if (code !== 0 && !closed) {
-          send({
-            type: "error",
-            message: stderr.trim().slice(0, 300) || `claude exited with code ${code}`,
-          });
-        }
-        if (!closed) {
-          try {
-            controller.close();
-          } catch {
-            // already closed
+        });
+
+        proc.stderr.on("data", (chunk: Buffer) => {
+          stderr += chunk.toString("utf8");
+        });
+
+        proc.on("close", (code) => {
+          if (code !== 0 && !closed) {
+            send({
+              type: "error",
+              message: stderr.trim().slice(0, 300) || `claude exited with code ${code}`,
+            });
           }
-          closed = true;
-        }
-      });
+          finish();
+        });
 
-      proc.on("error", (err) => {
-        if (!closed) {
-          send({ type: "error", message: `Failed to spawn claude: ${err.message}` });
-          try {
-            controller.close();
-          } catch {
-            // already closed
+        proc.on("error", (err) => {
+          if (!closed) {
+            send({ type: "error", message: `Failed to spawn claude: ${err.message}` });
+            finish();
           }
-          closed = true;
-        }
-      });
+        });
 
-      // If the client aborts, kill the subprocess.
-      request.signal.addEventListener("abort", () => {
-        try {
-          proc.kill("SIGTERM");
-        } catch {
-          // ignore
-        }
-        if (!closed) {
-          try {
-            controller.close();
-          } catch {
-            // already closed
-          }
-          closed = true;
-        }
-      });
+        request.signal.addEventListener("abort", () => {
+          try { proc.kill("SIGTERM"); } catch { /* ignore */ }
+          finish();
+        });
+      }
     },
   });
 

package/app/apps/web/app/api/events/route.ts

@@ -14,17 +14,16 @@
  * changed file so the next RSC render re-parses fresh data.
  */
 
-import { invalidateFile, DEFAULT_ROOT } from "@claude-lens/parser/fs";
+import { invalidateFile, DEFAULT_ROOT, cclensHome } from "@claude-lens/parser/fs";
 import { watch, promises as fs, existsSync } from "node:fs";
 import path from "node:path";
-import { homedir } from "node:os";
 
 export const dynamic = "force-dynamic";
 // Edge runtime can't do fs.watch
 export const runtime = "nodejs";
 
-/** ~/.cclens/usage.jsonl — written by the cclens daemon every 5 minutes. */
-const USAGE_LOG_DIR = path.join(homedir(), ".cclens");
+/** cclensHome()/usage.jsonl — written by the cclens daemon every 5 minutes. */
+const USAGE_LOG_DIR = cclensHome();
 const USAGE_LOG_FILE = "usage.jsonl";
 
 type LiveEvent =

package/app/apps/web/app/api/runs/[runId]/route.ts

@@ -1,11 +1,11 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { cclensPath } from "@claude-lens/parser/fs";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
-const RUNS_DIR = join(homedir(), ".cclens", "llm-runs");
+const RUNS_DIR = cclensPath("llm-runs");
 
 /**
  * GET /api/runs/<runId>           dump the full event trace

package/app/apps/web/app/api/runs/[runId]/stream/route.ts

@@ -1,11 +1,12 @@
 import { existsSync, readdirSync, statSync, watch, openSync, readSync, closeSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { homedir } from "node:os";
+import { cclensPath } from "@claude-lens/parser/fs";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
-const RUNS_DIR = join(homedir(), ".cclens", "llm-runs");
+const RUNS_DIR = cclensPath("llm-runs");
 
 /**
  * GET /api/runs/<runId>/stream  → SSE tail of a per-run trace file

package/app/apps/web/app/api/runs/route.ts

@@ -1,7 +1,7 @@
 import { execSync } from "node:child_process";
 import { existsSync, readFileSync, readdirSync, statSync, openSync, readSync, closeSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { cclensPath } from "@claude-lens/parser/fs";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
@@ -57,8 +57,12 @@ function listActiveRuns(): ActiveRun[] {
   }
   const runs: ActiveRun[] = [];
   for (const line of out.split("\n")) {
-    if (!line.includes("claude -p")) continue;
+    // Match both `claude -p` (print mode) and tmux-driven interactive
+    // (no `-p`). The shared marker is `--append-system-prompt`, which
+    // the LLM-runner pipeline always sets — interactive user sessions
+    // launched from a terminal don't carry it.
     if (!line.includes("--append-system-prompt")) continue;
+    if (!/\bclaude\b/.test(line)) continue;
     if (line.includes("grep")) continue;
     const m = line.trim().match(/^(\d+)\s+(\S+)\s+([\d:.]+)\s+(.+)$/);
     if (!m) continue;
@@ -74,7 +78,7 @@ function listActiveRuns(): ActiveRun[] {
   return runs.sort((a, b) => a.elapsed_s - b.elapsed_s);
 }
 
-const SPEND_PATH = join(homedir(), ".cclens", "llm-spend.jsonl");
+const SPEND_PATH = cclensPath("llm-spend.jsonl");
 
 type CompletedRun = {
   ts: string;
@@ -123,7 +127,7 @@ function parseSince(s: string | null): number {
   return Date.now() - 24 * 3_600_000;
 }
 
-const RUNS_DIR = join(homedir(), ".cclens", "llm-runs");
+const RUNS_DIR = cclensPath("llm-runs");
 
 type TraceSummary = {
   run_id: string;

package/app/apps/web/app/sessions/[id]/session-view.tsx

@@ -292,34 +292,42 @@ export function SessionView({
   /** Detect PR creations in this session. */
   const prMarkers = useMemo(() => detectPrMarkers(session), [session]);
 
-  /** Idle bands derived from raw event timestamps, classified per gap.
+  /** Idle bands derived from raw event timestamps. Anchors include every
+   *  timestamped event (agent-thinking and meta are activity too), and
+   *  each emitted band's `start..end` is a literal time range so the
+   *  minimap stripe width tracks actual idle duration — no across-gap
+   *  merging.
    *
-   *  Two flavors:
-   *    - In-turn idle (gap between agent activities within the same user
-   *      turn) — multiple of these inside one turn collapse into ONE merged
-   *      band whose `start..end` spans the whole period and `durationMs`
-   *      sums the actual idle.
-   *    - Between-turn idle (gap whose terminating anchor IS a user message)
-   *      — emitted standalone. This is "user paused, walked away, came
-   *      back" time and is conceptually distinct from agent thinking.
-   *
-   *  Anchors only count user / agent / tool-call / tool-result events —
-   *  meta + thinking events are skipped so sub-second event-to-event gaps
-   *  don't crowd the strip.
+   *  Two exclusions keep "delegated work" and "response latency" out of
+   *  idle:
+   *    - Subagent run spans are carved out of every candidate gap. When a
+   *      parent dispatches an Agent tool call the gap between tool_use and
+   *      tool_result is the subagent's runtime — not idle. Background
+   *      runs that overlap a user-away gap likewise get clipped out so
+   *      only the genuinely-unwatched portion remains. The carve can
+   *      produce multiple surviving slices per gap; each becomes its own
+   *      band so the visual extent matches reality.
+   *    - "Awaiting first response" — the period between a user message
+   *      and the first agent/tool-call anchor — is dropped wholesale,
+   *      even if intermediate thinking/meta anchors split it into
+   *      multiple sub-gaps. Long model reasoning before the first reply
+   *      is composing, not idle. (User→user gaps still register as
+   *      between-turn idle because no agent activity occurred between.)
    *
    *  Side effect: the leading warm-up gap before the first agent response
    *  drops out unless it crosses MIN_GAP_MS — which the first 6s in a
    *  typical Codex session does not. */
   const rawIdleBands = useMemo(() => {
-    const isAnchor = (role: string) =>
-      role === "user" ||
-      role === "agent" ||
-      role === "tool-call" ||
-      role === "tool-result";
-    const MIN_GAP_MS = 10_000;
+    // Anchor on ANY timestamped event so agent-thinking, meta, and other
+    // intra-turn signals prove the parent is doing work. Only what we
+    // need to distinguish is "user" (turn boundary) vs everything else.
+    const isUserRole = (role: string) => role === "user";
+    // 30s threshold: keeps ordinary tool latency (Read big file, slow Bash,
+    // model thinking between anchors) out of the idle stripes while still
+    // catching anything that reads as a real pause.
+    const MIN_GAP_MS = 30_000;
     const anchors: { ms: number; role: string }[] = [];
     for (const e of events) {
-      if (!isAnchor(e.role)) continue;
       if (!e.timestamp) continue;
       const ms = Date.parse(e.timestamp);
       if (!Number.isFinite(ms)) continue;
@@ -329,38 +337,103 @@ export function SessionView({
     anchors.sort((a, b) => a.ms - b.ms);
     const sessionStartMs = anchors[0]!.ms - (events.find((e) => e.timestamp)?.tOffsetMs ?? 0);
 
+    const subagentSpans = (session.subagents ?? [])
+      .filter(
+        (s): s is SubagentRun & { startTOffsetMs: number; endTOffsetMs: number } =>
+          s.startTOffsetMs !== undefined && s.endTOffsetMs !== undefined,
+      )
+      .map((s) => ({ start: s.startTOffsetMs, end: s.endTOffsetMs }))
+      .sort((a, b) => a.start - b.start);
+
+    /** Subtract subagent spans from [start, end] in offset coordinates,
+     *  returning 0+ remaining slices in time order. */
+    const carveOutSubagents = (
+      start: number,
+      end: number,
+    ): { start: number; end: number }[] => {
+      let pieces: { start: number; end: number }[] = [{ start, end }];
+      for (const span of subagentSpans) {
+        if (span.end <= start) continue;
+        if (span.start >= end) break;
+        const next: { start: number; end: number }[] = [];
+        for (const p of pieces) {
+          if (span.end <= p.start || span.start >= p.end) {
+            next.push(p);
+            continue;
+          }
+          if (span.start > p.start) next.push({ start: p.start, end: span.start });
+          if (span.end < p.end) next.push({ start: span.end, end: p.end });
+        }
+        pieces = next;
+      }
+      return pieces;
+    };
+
+    const overlapsSubagent = (start: number, end: number): boolean => {
+      for (const span of subagentSpans) {
+        if (span.end <= start) continue;
+        // subagentSpans is sorted by start, so once span.start >= end no
+        // later span can overlap [start, end] either — bail out cleanly.
+        if (span.start >= end) return false;
+        return true;
+      }
+      return false;
+    };
+
     type Band = { start: number; end: number; durationMs: number };
     const bands: Band[] = [];
-    let inTurn: Band | null = null;
 
-    const flushInTurn = () => {
-      if (inTurn && inTurn.durationMs > MIN_GAP_MS) bands.push(inTurn);
-      inTurn = null;
-    };
+    // "Awaiting first response" — true after a user message, false once an
+    // agent or tool-call anchor proves the model started replying.
+    // Thinking and meta events don't clear it, so a user→thinking→agent
+    // sequence where thinking→agent crosses MIN_GAP_MS still reads as
+    // response latency rather than idle.
+    let awaitingFirstResponse = false;
+    if (anchors[0]) {
+      if (isUserRole(anchors[0].role)) awaitingFirstResponse = true;
+    }
 
     for (let i = 1; i < anchors.length; i++) {
-      const gap = anchors[i]!.ms - anchors[i - 1]!.ms;
-      if (gap <= MIN_GAP_MS) continue;
+      const rawGap = anchors[i]!.ms - anchors[i - 1]!.ms;
+      const curRole = anchors[i]!.role;
+      // Snapshot the phase BEFORE updating, so the gap is classified by
+      // the state at its start (anchors[i-1]).
+      const skipAsLatency = awaitingFirstResponse && !isUserRole(curRole);
+
+      if (isUserRole(curRole)) awaitingFirstResponse = true;
+      else if (curRole === "agent" || curRole === "tool-call") awaitingFirstResponse = false;
+
+      if (rawGap <= MIN_GAP_MS) continue;
+      if (skipAsLatency) continue;
+
       const gStart = anchors[i - 1]!.ms - sessionStartMs;
       const gEnd = anchors[i]!.ms - sessionStartMs;
+      const betweenTurn = isUserRole(curRole);
+
+      if (!betweenTurn) {
+        // In-turn gap: the parent is mid-turn. If any subagent run overlaps,
+        // the parent is waiting on delegated work — not idle. Drop the
+        // whole gap rather than carving out startup/teardown slivers that
+        // would clutter the minimap with thin stripes. Gaps with no
+        // subagent overlap (long Bash runs, model thinking between tool
+        // calls) still emit as a single band.
+        if (overlapsSubagent(gStart, gEnd)) continue;
+        bands.push({ start: gStart, end: gEnd, durationMs: gEnd - gStart });
+        continue;
+      }
 
-      if (anchors[i]!.role === "user") {
-        // Between-turn idle — close any in-progress in-turn merge first,
-        // then push the between-turn band on its own.
-        flushInTurn();
-        bands.push({ start: gStart, end: gEnd, durationMs: gap });
-      } else {
-        // In-turn idle — accumulate into the running merged band.
-        if (!inTurn) inTurn = { start: gStart, end: gEnd, durationMs: gap };
-        else {
-          inTurn.end = gEnd;
-          inTurn.durationMs += gap;
+      // Between-turn gap: user walked away. Carve out background subagent
+      // activity so only the genuinely-unwatched portion counts as idle.
+      // Each surviving slice becomes its own band.
+      for (const slice of carveOutSubagents(gStart, gEnd)) {
+        const dur = slice.end - slice.start;
+        if (dur > MIN_GAP_MS) {
+          bands.push({ start: slice.start, end: slice.end, durationMs: dur });
         }
       }
     }
-    flushInTurn();
     return bands;
-  }, [events]);
+  }, [events, session.subagents]);
 
   const coldResumeMarkers = useMemo(() => {
     const seen = new Set<string>();
@@ -621,6 +694,12 @@ export function SessionView({
           </span>
           <InlineStatDivider />
           {model && <InlineStat icon={<Cpu size={12} />} value={model} mono />}
+          {session.entrypoint && (
+            <>
+              <InlineStatDivider />
+              <EntrypointBadge entrypoint={session.entrypoint} />
+            </>
+          )}
           <InlineStatDivider />
           <InlineStat icon={<Folder size={12} />} value={projectName} truncate />
           <InlineStatDivider />
@@ -1143,6 +1222,31 @@ function InlineStatDivider() {
   );
 }
 
+function EntrypointBadge({ entrypoint }: { entrypoint: string }) {
+  // cli + claude-desktop are human-driven; sdk-* are programmatic.
+  const isSdk = entrypoint.startsWith("sdk-");
+  const tone = isSdk
+    ? { bg: "rgba(245, 158, 11, 0.16)", fg: "#b45309" }
+    : { bg: "rgba(16, 185, 129, 0.16)", fg: "#047857" };
+  return (
+    <span
+      title={`entrypoint: ${entrypoint}`}
+      style={{
+        fontSize: 10.5,
+        padding: "2px 7px",
+        borderRadius: 4,
+        background: tone.bg,
+        color: tone.fg,
+        fontWeight: 600,
+        fontFamily: "var(--font-mono)",
+        letterSpacing: 0.2,
+      }}
+    >
+      {entrypoint}
+    </span>
+  );
+}
+
 function InlineTokenStat({ usage }: { usage: SessionEvent["usage"] }) {
   const { ref, anchor, open, close } = useAnchoredTooltip();
   const u = usage ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
@@ -2637,14 +2741,15 @@ function TranscriptList({
   }
 
   const idleBandList = (rawIdleBands ?? []).slice().sort((a, b) => a.start - b.start);
-  /** Returns the durationMs of the idle band that ends at (or just before)
-   *  the given row's tOffset, or null if no band matches. Tolerance is 1s
-   *  to absorb Date.parse rounding differences between anchor.ms and the
-   *  presentation row's tOffsetMs. */
-  const idleBeforeOffset = (tOff: number | undefined): number | null => {
+  /** Returns the first matching idle band (or null) whose end falls within
+   *  1s of the given row's tOffset. Tolerance absorbs Date.parse rounding
+   *  between anchor.ms and the presentation row's tOffsetMs. */
+  const idleBandBeforeOffset = (
+    tOff: number | undefined,
+  ): { start: number; durationMs: number } | null => {
     if (tOff === undefined) return null;
     for (const b of idleBandList) {
-      if (Math.abs(b.end - tOff) < 1000) return b.durationMs;
+      if (Math.abs(b.end - tOff) < 1000) return b;
     }
     return null;
   };
@@ -2656,6 +2761,11 @@ function TranscriptList({
   };
 
   const out: React.ReactNode[] = [];
+  // A user row and the turn-collapsed row that follows it share a
+  // tOffsetMs (turn anchors at the user message — see buildMegaRows), so
+  // both would match the same between-turn band without this guard. Track
+  // emitted band starts and skip duplicates.
+  const emittedBandStarts = new Set<number>();
   for (let i = 0; i < displayRows.length; i++) {
     const d = displayRows[i];
     // Emit a "Session idle" divider before any row that starts right after
@@ -2663,9 +2773,14 @@ function TranscriptList({
     // expanded turn doesn't render dividers for its inner steps.
     const indented = d.kind === "presentation" ? d.indented : false;
     if (!indented) {
-      const idleMs = idleBeforeOffset(rowTOffset(d));
-      if (idleMs !== null && idleMs > IDLE_THRESHOLD_MS) {
-        out.push(<IdleDivider key={`idle-before-${i}`} gapMs={idleMs} />);
+      const band = idleBandBeforeOffset(rowTOffset(d));
+      if (
+        band !== null &&
+        band.durationMs > IDLE_THRESHOLD_MS &&
+        !emittedBandStarts.has(band.start)
+      ) {
+        emittedBandStarts.add(band.start);
+        out.push(<IdleDivider key={`idle-before-${i}`} gapMs={band.durationMs} />);
       }
     }