fleetlens 0.9.0 → 0.10.1

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

@@ -621,6 +621,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 +1149,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 };

package/app/apps/web/components/job-queue-widget.tsx

@@ -40,34 +40,37 @@ export function JobQueueWidget() {
     });
   };
 
-  // Poll /api/jobs. Faster cadence when there's anything active.
+  // Poll /api/jobs. Faster cadence when there's anything active. Empty
+  // deps + closure-local `hasActive` — listing `jobs` here would re-run
+  // the effect on every successful tick (because setJobs changes the
+  // ref), collapsing the throttle into a tight 1–4 ms refetch loop.
   useEffect(() => {
     let mounted = true;
     let timeoutId: ReturnType<typeof setTimeout> | null = null;
+    let hasActive = false;
 
     const tick = async () => {
       try {
         const res = await fetch("/api/jobs", { cache: "no-store" });
         if (!res.ok) return;
         const data = await res.json() as { jobs: Job[] };
-        if (mounted) setJobs(data.jobs);
+        if (!mounted) return;
+        setJobs(data.jobs);
+        hasActive = data.jobs.some(j => j.status === "running" || j.status === "queued");
       } catch { /* ignore */ }
     };
 
     const schedule = () => {
       if (!mounted) return;
-      const hasActive = jobs.some(j => j.status === "running" || j.status === "queued");
-      const delay = hasActive ? 1500 : 6000;
-      timeoutId = setTimeout(async () => { await tick(); schedule(); }, delay);
+      timeoutId = setTimeout(async () => { await tick(); schedule(); }, hasActive ? 1500 : 6000);
     };
 
-    void tick();
-    schedule();
+    void tick().then(schedule);
     return () => {
       mounted = false;
       if (timeoutId) clearTimeout(timeoutId);
     };
-  }, [jobs]);
+  }, []);
 
   const active = jobs.filter(j => j.status === "running" || j.status === "queued");
   const recent = jobs.filter(j => j.status === "done" || j.status === "error" || j.status === "cancelled").slice(0, 8);

package/app/apps/web/components/previous-cycles-trend.tsx

@@ -1,10 +1,19 @@
 import type { CyclePeak } from "@/lib/calibration-data";
+import {
+  paceToneForCycle,
+  toneVar,
+  utilizationTone,
+} from "@/lib/utilization-tone";
 
-// Horizontal bar chart of the last few cycles' peak utilization. One bar
-// per cycle, height proportional to peak %, color follows the burndown
-// danger thresholds (green / amber / red). The right-most bar is "current"
-// (in-progress) and gets a distinct styling so it isn't read as a finished
-// trend point. Designed for direct reuse on the team-edition member card.
+const HOUR = 3_600_000;
+const WINDOW_MS = { "5h": 5 * HOUR, "7d": 7 * 24 * HOUR } as const;
+
+// Horizontal bar chart of recent cycle peaks. Color logic differs by
+// cycle state: completed cycles are colored by their final peak (≥70%
+// green = full plan use, <40% red = wasted headroom), in-progress cycles
+// are colored by PACE (utilization vs elapsed cycle fraction) so a 50%
+// peak halfway through a 7-day cycle reads on-pace green, not amber.
+// Right-most bar is the in-progress cycle, dashed border + transparency.
 export function PreviousCyclesTrend({
   windowLabel,
   cycles,
@@ -51,19 +60,25 @@ export function PreviousCyclesTrend({
         }}
       >
         {cycles.map((c, i) => (
-          <CycleBar key={i} cycle={c} />
+          <CycleBar key={i} cycle={c} windowLabel={windowLabel} />
         ))}
       </div>
     </section>
   );
 }
 
-function CycleBar({ cycle }: { cycle: CyclePeak }) {
+function CycleBar({
+  cycle,
+  windowLabel,
+}: {
+  cycle: CyclePeak;
+  windowLabel: "5h" | "7d";
+}) {
   const pct = Math.max(0, Math.min(100, cycle.peakPct));
-  const color =
-    pct >= 90 ? "var(--af-danger)" :
-    pct >= 70 ? "#b58400" :
-    "var(--af-success)";
+  const tone = cycle.current
+    ? paceToneForCycle(pct, new Date(cycle.endsAt).getTime(), WINDOW_MS[windowLabel])
+    : utilizationTone(pct);
+  const color = toneVar(tone);
   const date = new Date(cycle.endsAt);
   // Compact "Apr 23" date label; "current" cycle gets "ends Apr 30" instead
   const label = cycle.current

package/app/apps/web/components/usage-chart.tsx

@@ -1,23 +1,24 @@
 "use client";
 
-import { useMemo, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import { Maximize2 } from "lucide-react";
 import type { UsageSnapshot, UsageWindow } from "@/lib/usage-data";
+import { paceLabel, toneVar } from "@/lib/utilization-tone";
 
 type SeriesKey = "five_hour" | "seven_day" | "seven_day_sonnet";
 
 /**
- * Sprint-burndown-style chart for a single usage window.
+ * Burndown-style chart for a single usage window.
  *
- * Y-axis: remaining budget (100% at start, 0% when quota is exhausted)
+ * Y-axis: remaining budget (100% at start, 0% when quota exhausts)
  * X-axis: time from window start to reset
  *
  * Ideal line: dashed diagonal from (windowStart, 100%) to (resetsAt, 0%)
- *   — the "sustainable burn" trajectory
- * Actual line: solid, plots (100 - utilization) at each snapshot's captured_at
+ *   — full-utilization trajectory.
  *
- * ABOVE the ideal line = saving budget (on track)
- * BELOW the ideal line = burning faster than sustainable (behind schedule)
+ * BELOW the ideal line = burning at or above pace (getting plan value)
+ * ABOVE the ideal line = under-burning (paying for unused headroom)
+ * Far below ideal      = will exhaust before reset (throttling risk)
  */
 export function UsageChart({
   snapshots,
@@ -90,6 +91,14 @@ export function UsageChart({
     predicted: number | null;
   } | null>(null);
 
+  // SSR can't agree with the client on `Date.now()` — the server renders
+  // at request time, the client hydrates milliseconds-to-minutes later.
+  // Both depended on `now`, so the "now" cursor + pace label produced
+  // a hydration mismatch warning. Render time-dependent UI only after
+  // mount; the SSR fragment matches the client's pre-mount fragment.
+  const [mounted, setMounted] = useState(false);
+  useEffect(() => setMounted(true), []);
+
   if (!computed) {
     return (
       <div
@@ -121,14 +130,9 @@ export function UsageChart({
 
   const nowIdeal = idealAt(now);
   const delta = currentRemaining - nowIdeal;
-  const toneColor =
-    delta < -10
-      ? "var(--af-danger)"
-      : delta < 0
-        ? "var(--af-warning)"
-        : "var(--af-success)";
-  const toneLabel =
-    delta < -10 ? "behind schedule" : delta < 0 ? "slightly behind" : "on track";
+  const pace = paceLabel(delta);
+  const toneColor = toneVar(pace.tone);
+  const toneLabel = pace.label;
 
   const linePath =
     points.length > 0
@@ -226,9 +230,16 @@ export function UsageChart({
             remaining
           </span>
         </div>
-        <div style={{ fontSize: 11, color: toneColor, fontWeight: 500 }}>
-          {toneLabel} ({delta >= 0 ? "+" : ""}
-          {delta.toFixed(1)}%)
+        <div
+          suppressHydrationWarning
+          style={{ fontSize: 11, color: toneColor, fontWeight: 500 }}
+        >
+          {mounted && (
+            <>
+              {toneLabel} ({delta >= 0 ? "+" : ""}
+              {delta.toFixed(1)}pp)
+            </>
+          )}
         </div>
         <div
           suppressHydrationWarning
@@ -338,23 +349,9 @@ export function UsageChart({
             {formatAxisDatetime(windowEnd)}
           </text>
 
-          {/* Danger (<10% remaining) and caution (10–30%) bands at the bottom */}
-          <rect
-            x={padding.left}
-            y={yScale(10)}
-            width={plotW}
-            height={yScale(0) - yScale(10)}
-            fill="var(--af-danger)"
-            fillOpacity="0.07"
-          />
-          <rect
-            x={padding.left}
-            y={yScale(30)}
-            width={plotW}
-            height={yScale(10) - yScale(30)}
-            fill="var(--af-warning)"
-            fillOpacity="0.05"
-          />
+          {/* No static danger bands. Low-remaining used to be flagged red,
+              but in the "high use = good" framing that band is the goal
+              zone. Pace label + ideal line carry the signal. */}
 
           {/* Area fill under actual line */}
           <path d={areaPath} fill={colorVar} fillOpacity="0.1" />
@@ -371,8 +368,9 @@ export function UsageChart({
             strokeDasharray="4 3"
           />
 
-          {/* Current-time vertical marker */}
-          {now >= windowStart && now <= windowEnd && (
+          {/* Current-time vertical marker — only after mount so the SSR
+              and client renders agree (Date.now() differs between them). */}
+          {mounted && now >= windowStart && now <= windowEnd && (
             <g>
               <line
                 x1={xScale(now)}