@saadnvd1/agent-os 0.3.620 → 0.3.624

package/components/Pane/PaneViewToggle.test.ts

@@ -0,0 +1,82 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { showGitToggle } from "./git-visibility";
+import { PaneViewToggle } from "./PaneViewToggle";
+
+// Radix tooltips need a real browser; plain elements show what's rendered.
+vi.mock("@/components/ui/tooltip", async () => {
+  const { createElement: h } = await import("react");
+  const part = (props: { children?: unknown }) =>
+    h("span", null, props.children as never);
+  return {
+    Tooltip: part,
+    TooltipTrigger: part,
+    TooltipContent: () => null,
+  };
+});
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+describe("showGitToggle", () => {
+  it("shows for a local repo", () => {
+    expect(showGitToggle(true, true)).toBe(true);
+  });
+  it("keeps showing while the check is unknown", () => {
+    expect(showGitToggle(true, undefined)).toBe(true);
+  });
+  it("hides outside a repo", () => {
+    expect(showGitToggle(true, false)).toBe(false);
+  });
+  it("hides for a remote session", () => {
+    expect(showGitToggle(false, true)).toBe(false);
+    expect(showGitToggle(false, undefined)).toBe(false);
+  });
+});
+
+describe("PaneViewToggle", () => {
+  let host: HTMLElement;
+  let root: Root;
+  beforeEach(() => {
+    host = document.createElement("div");
+    document.body.appendChild(host);
+    root = createRoot(host);
+  });
+  afterEach(() => {
+    act(() => root.unmount());
+    host.remove();
+  });
+  const render = (showGit: boolean) =>
+    act(() => {
+      root.render(
+        createElement(PaneViewToggle, {
+          viewMode: "terminal",
+          isLocalSession: true,
+          showGit,
+          isConductor: false,
+          workerCount: 0,
+          gitDrawerOpen: false,
+          shellDrawerOpen: false,
+          onViewModeChange: () => {},
+          onGitDrawerToggle: () => {},
+          onShellDrawerToggle: () => {},
+        })
+      );
+    });
+  const has = (label: string) =>
+    !!host.querySelector(`[aria-label="${label}"]`);
+
+  it("omits Git outside a repo but keeps Files and Shell", () => {
+    render(false);
+    expect(has("Git")).toBe(false);
+    expect(has("Files")).toBe(true);
+    expect(has("Shell")).toBe(true);
+  });
+  it("shows Git in a repo", () => {
+    render(true);
+    expect(has("Git")).toBe(true);
+  });
+});

package/components/Pane/PaneViewToggle.tsx

@@ -22,6 +22,8 @@ interface PaneViewToggleProps {
   isChat?: boolean;
   viewMode: ViewMode;
   isLocalSession: boolean;
+  // Local, and the folder is not known to be outside a git repository.
+  showGit: boolean;
   isConductor: boolean;
   // The task merged and has a log.
   hasLog?: boolean;
@@ -80,6 +82,7 @@ export function PaneViewToggle({
   isChat,
   viewMode,
   isLocalSession,
+  showGit,
   isConductor,
   hasLog,
   workerCount,
@@ -107,13 +110,15 @@ export function PaneViewToggle({
           >
             <FolderOpen className="h-3.5 w-3.5" />
           </ToggleButton>
-          <ToggleButton
-            label="Git"
-            active={gitDrawerOpen}
-            onClick={onGitDrawerToggle}
-          >
-            <GitBranch className="h-3.5 w-3.5" />
-          </ToggleButton>
+          {showGit && (
+            <ToggleButton
+              label="Git"
+              active={gitDrawerOpen}
+              onClick={onGitDrawerToggle}
+            >
+              <GitBranch className="h-3.5 w-3.5" />
+            </ToggleButton>
+          )}
           <ToggleButton
             label="Shell"
             active={shellDrawerOpen}

package/components/Pane/git-visibility.ts

@@ -0,0 +1,9 @@
+// The Git toggle shows for a local session unless its folder is known not to
+// be a repository. Unknown (still checking) keeps it, so it doesn't flicker
+// away in real repos.
+export function showGitToggle(
+  isLocalSession: boolean,
+  isGitRepo: boolean | undefined
+): boolean {
+  return isLocalSession && isGitRepo !== false;
+}

package/components/Pane/index.tsx

@@ -34,6 +34,8 @@ import { ShellDrawer } from "@/components/ShellDrawer";
 import { useSnapshot } from "valtio";
 import { fileOpenStore, fileOpenActions } from "@/stores/fileOpen";
 import { useDemoMode } from "@/data/demo";
+import { useIsGitRepo } from "@/data/git/queries";
+import { showGitToggle } from "./git-visibility";
 import { DemoNotice } from "@/components/DemoNotice";
 
 // Dynamic imports for client-only components with loading states
@@ -170,7 +172,19 @@ export const Pane = memo(function Pane({
     : null;
   const isLocalSession = !session?.host_id || session.host_id === "local";
   // An orchestrator works through tools in a scratch folder: no repo to show.
-  const showGitDrawer = gitDrawerOpen && session?.role !== "orchestrator";
+  const isGitRepo = useIsGitRepo(
+    session?.working_directory ?? undefined,
+    isLocalSession && !!session?.working_directory
+  );
+  const showGit = showGitToggle(isLocalSession, isGitRepo);
+  const showGitDrawer =
+    gitDrawerOpen && showGit && session?.role !== "orchestrator";
+  // The folder turned out not to be a repo: don't leave its git view open.
+  useEffect(() => {
+    if (isGitRepo !== false) return;
+    if (gitDrawerOpen) setGitDrawerOpen(false);
+    if (viewMode === "git") setViewMode("terminal");
+  }, [isGitRepo, gitDrawerOpen, viewMode, setGitDrawerOpen, setViewMode]);
   // A tab whose session runs as chat shows the conversation, not a terminal.
   const chatSessionFor = (tab: { sessionId: string | null }) => {
     const s = tab.sessionId
@@ -458,6 +472,7 @@ export const Pane = memo(function Pane({
           isConductor={isConductor}
           hasLog={hasLog}
           workerCount={workerCount}
+          showGit={showGit}
           onMenuClick={onMenuClick}
           onViewModeChange={setViewMode}
           onSelectSession={onSelectSession}
@@ -484,6 +499,7 @@ export const Pane = memo(function Pane({
           canClose={canClose}
           hasAttachedTmux={!!activeTab?.attachedTmux}
           gitDrawerOpen={gitDrawerOpen}
+          showGit={showGit}
           shellDrawerOpen={shellDrawerOpen}
           onTabSwitch={(tabId) => switchTab(paneId, tabId)}
           onTabClose={(tabId) => closeTab(paneId, tabId)}
@@ -532,7 +548,7 @@ export const Pane = memo(function Pane({
           )}
 
           {/* Git - mobile only */}
-          {session?.working_directory && (
+          {session?.working_directory && showGit && (
             <div className={viewMode === "git" ? "h-full" : "hidden"}>
               <GitPanel
                 workingDirectory={session.working_directory}

package/components/SessionList/SidebarHeader.tsx

@@ -39,6 +39,7 @@ import { settingsUiActions } from "@/stores/settingsUi";
 import { usageUiActions } from "@/stores/usageUi";
 import { WorkspaceSwitcher } from "./WorkspaceSwitcher";
 import { LoadGauge } from "./LoadGauge";
+import { HealthDot } from "@/components/Health/HealthDot";
 import { AwayToggle } from "@/components/Away/AwayToggle";
 import { NoApprovalsBadge } from "@/components/Approvals/NoApprovalsBadge";
 import { useSchedulesGlance } from "./useSchedulesGlance";
@@ -71,6 +72,7 @@ export function SidebarHeader(props: SidebarHeaderProps) {
           current={props.workspace}
         />
         <LoadGauge />
+        <HealthDot />
       </div>
       <div className="ml-auto flex shrink-0 items-center gap-0.5">
         <NoApprovalsBadge />

package/components/Settings/SettingsDialog.tsx

@@ -11,6 +11,7 @@ import {
   Clock,
   Cpu,
   GitMerge,
+  HeartPulse,
   LayoutGrid,
   Link2,
   ListChecks,
@@ -30,6 +31,7 @@ import {
 } from "@/components/ui/dialog";
 import { Button } from "@/components/ui/button";
 import { AuditsPanel } from "@/components/Audits/AuditsPanel";
+import { HealthPanel } from "@/components/Health/HealthPanel";
 import { DevicesPanel } from "@/components/Devices";
 import { GlobalMergeSection } from "@/components/Merge/GlobalMergeSection";
 import { ModelsSection } from "@/components/Models/ModelsSection";
@@ -105,6 +107,11 @@ export const SECTION_INFO: Record<
     hint: "Where sessions spent tokens and repeated work",
     icon: ClipboardList,
   },
+  health: {
+    label: "Health",
+    hint: "What the watchers caught, what normal looks like, thresholds",
+    icon: HeartPulse,
+  },
   setup: {
     label: "Setup & health",
     hint: "What this machine has, agents, first-run setup",
@@ -150,6 +157,8 @@ function SectionBody({
       return <SchedulesPanel />;
     case "audits":
       return <AuditsPanel />;
+    case "health":
+      return <HealthPanel />;
     case "setup":
       return <SetupSection />;
     case "updates":

package/data/git/queries.ts

@@ -43,15 +43,28 @@ async function fetchGitCheck(path: string): Promise<GitCheck> {
   return res.json();
 }
 
-export function useGitCheck(path: string) {
+export function useGitCheck(
+  path: string,
+  options?: { enabled?: boolean; staleTime?: number }
+) {
   return useQuery({
     queryKey: gitKeys.check(path),
     queryFn: () => fetchGitCheck(path),
-    staleTime: 10000,
-    enabled: !!path && path !== "~",
+    staleTime: options?.staleTime ?? 10000,
+    enabled: !!path && path !== "~" && (options?.enabled ?? true),
   });
 }
 
+// Whether a folder is a git repository; undefined while it isn't known
+// (loading, disabled, or the check failed).
+export function useIsGitRepo(
+  path: string | undefined,
+  enabled: boolean
+): boolean | undefined {
+  const { data } = useGitCheck(path ?? "", { enabled, staleTime: 60000 });
+  return typeof data?.isGitRepo === "boolean" ? data.isGitRepo : undefined;
+}
+
 // --- Git Status ---
 
 async function fetchGitStatus(workingDir: string): Promise<GitStatus> {

package/data/health/index.ts

@@ -0,0 +1,111 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { HealthView } from "@/lib/health/view";
+import type { NoteRow } from "@/lib/health/notes";
+import type { Area } from "@/lib/health/types";
+
+export const healthKeys = {
+  all: ["health"] as const,
+  view: () => [...healthKeys.all, "view"] as const,
+  count: () => [...healthKeys.all, "count"] as const,
+  notes: () => [...healthKeys.all, "notes"] as const,
+  config: () => [...healthKeys.all, "config"] as const,
+};
+
+async function request<T>(url: string, init?: RequestInit): Promise<T> {
+  const res = await fetch(url, init);
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || "Request failed");
+  return data as T;
+}
+
+const json = (method: string, body: unknown): RequestInit => ({
+  method,
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify(body),
+});
+
+const POLL_MS = 30_000;
+
+export function useHealthQuery() {
+  return useQuery({
+    queryKey: healthKeys.view(),
+    queryFn: () => request<HealthView>("/api/health/anomalies"),
+    refetchInterval: POLL_MS,
+  });
+}
+
+// What the sidebar dot needs, and nothing more.
+export function useHealthCount() {
+  return useQuery({
+    queryKey: healthKeys.count(),
+    queryFn: () =>
+      request<{ open: number; needsYou: number }>(
+        "/api/health/anomalies?count=1"
+      ),
+    refetchInterval: POLL_MS,
+  });
+}
+
+export function useDismissAnomaly() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (id: number) =>
+      request(
+        "/api/health/anomalies",
+        json("PATCH", { id, action: "dismiss" })
+      ),
+    onSuccess: () => qc.invalidateQueries({ queryKey: healthKeys.all }),
+  });
+}
+
+export interface NotesResponse {
+  seeds: Record<Area, string[]>;
+  notes: NoteRow[];
+}
+
+export function useHealthNotes() {
+  return useQuery({
+    queryKey: healthKeys.notes(),
+    queryFn: () => request<NotesResponse>("/api/health/notes"),
+  });
+}
+
+export function useAddNote() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (note: { area: Area; line: string }) =>
+      request("/api/health/notes", json("POST", note)),
+    onSuccess: () => qc.invalidateQueries({ queryKey: healthKeys.notes() }),
+  });
+}
+
+export function useDeleteNote() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (id: number) =>
+      request(`/api/health/notes?id=${id}`, { method: "DELETE" }),
+    onSuccess: () => qc.invalidateQueries({ queryKey: healthKeys.notes() }),
+  });
+}
+
+export interface ConfigResponse {
+  config: Record<string, number>;
+  defaults: Record<string, number>;
+  labels: Record<string, string>;
+}
+
+export function useHealthConfig() {
+  return useQuery({
+    queryKey: healthKeys.config(),
+    queryFn: () => request<ConfigResponse>("/api/health/config"),
+  });
+}
+
+export function useSaveConfig() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (patch: Record<string, number | null>) =>
+      request<ConfigResponse>("/api/health/config", json("PUT", { patch })),
+    onSuccess: (data) => qc.setQueryData(healthKeys.config(), data),
+  });
+}

package/lib/db/migrations/20261015T1500_health_watch.ts

@@ -0,0 +1,68 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261015T1500_health_watch",
+  up: (db) => {
+    // The health watcher (lib/health): anomalies its detectors open and
+    // the verdicts the watchers give, server boots, CI runs and the
+    // watchers' notes on what normal looks like. Additive; rows are kept.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS health_anomalies (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        check_id TEXT NOT NULL,
+        subject TEXT NOT NULL,
+        area TEXT NOT NULL,
+        severity TEXT NOT NULL,
+        line TEXT NOT NULL,
+        detail TEXT NOT NULL DEFAULT '{}',
+        workspace_id TEXT,
+        opened_at INTEGER NOT NULL,
+        last_seen_at INTEGER NOT NULL,
+        closed_at INTEGER,
+        close_reason TEXT,
+        muted_until INTEGER,
+        hits INTEGER NOT NULL DEFAULT 1,
+        woken_severity TEXT,
+        woken_at INTEGER,
+        verdict TEXT,
+        tokens_in INTEGER,
+        tokens_out INTEGER,
+        delivered_at INTEGER,
+        phoned_at INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS idx_health_anomalies_subject
+        ON health_anomalies(check_id, subject, closed_at);
+      CREATE INDEX IF NOT EXISTS idx_health_anomalies_opened
+        ON health_anomalies(opened_at);
+
+      CREATE TABLE IF NOT EXISTS health_boots (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        started_at INTEGER NOT NULL,
+        pid INTEGER NOT NULL,
+        head TEXT,
+        prev_seen_at INTEGER,
+        prev_bg TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS ci_runs (
+        project_id TEXT NOT NULL,
+        workspace_id TEXT,
+        pr_number INTEGER NOT NULL,
+        head TEXT NOT NULL,
+        pending_since INTEGER NOT NULL,
+        settled_at INTEGER,
+        PRIMARY KEY (project_id, pr_number, head)
+      );
+
+      CREATE TABLE IF NOT EXISTS watcher_notes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        area TEXT NOT NULL,
+        line TEXT NOT NULL,
+        source TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_watcher_notes_area
+        ON watcher_notes(area, id);
+    `);
+  },
+} satisfies Migration;

package/lib/health/boots.ts

@@ -0,0 +1,79 @@
+/**
+ * When the server started, and what it was doing when the last one stopped.
+ * A restart is invisible from inside the new process, and a signal handler
+ * would change how the old one exits, so each health tick leaves a
+ * heartbeat (when it last ran, and the background jobs then live) and the
+ * next boot reads it back.
+ */
+
+import { db } from "../db";
+import { gitSync } from "../git-exec";
+import { getSetting, putSetting } from "../settings-store";
+import { MIN } from "./types";
+
+const HEARTBEAT = "health.heartbeat";
+
+export interface Heartbeat {
+  at: number;
+  bg: string[];
+}
+
+export function leaveHeartbeat(at: number, bg: string[]): void {
+  putSetting(HEARTBEAT, JSON.stringify({ at, bg: bg.slice(0, 20) }));
+}
+
+function lastHeartbeat(): Heartbeat | null {
+  try {
+    const raw = getSetting(HEARTBEAT);
+    return raw ? (JSON.parse(raw) as Heartbeat) : null;
+  } catch {
+    return null;
+  }
+}
+
+function gitHead(): string | null {
+  try {
+    return gitSync(process.cwd(), ["rev-parse", "--short", "HEAD"], {
+      timeout: 3000,
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+export function recordBoot(now = Date.now(), pid = process.pid): void {
+  const prev = lastHeartbeat();
+  db.prepare(
+    `INSERT INTO health_boots (started_at, pid, head, prev_seen_at, prev_bg)
+     VALUES (?, ?, ?, ?, ?)`
+  ).run(
+    now,
+    pid,
+    gitHead(),
+    prev?.at ?? null,
+    prev ? JSON.stringify(prev.bg) : null
+  );
+}
+
+export interface BootRow {
+  id: number;
+  started_at: number;
+  pid: number;
+  head: string | null;
+  prev_seen_at: number | null;
+  prev_bg: string | null;
+}
+
+export const bootsSince = (since: number) =>
+  db
+    .prepare(
+      `SELECT * FROM health_boots WHERE started_at >= ? ORDER BY started_at`
+    )
+    .all(since) as BootRow[];
+
+export const recentBoots = (n = 6) =>
+  db
+    .prepare(`SELECT * FROM health_boots ORDER BY started_at DESC LIMIT ?`)
+    .all(n) as BootRow[];
+
+export const BOOT_WINDOW_MS = 24 * 60 * MIN;

package/lib/health/ci.ts

@@ -0,0 +1,90 @@
+/**
+ * How long CI takes, learned from what the orchestrator already sees. Each
+ * diff it reads every open PR's verdict; the first time a head is pending is
+ * when its run started (to within a diff), and the first time it isn't is
+ * when it settled. No extra gh call.
+ */
+
+import { db } from "../db";
+import type { SessionFacts } from "../orchestrator/facts";
+import { MIN, type CiFact } from "./types";
+
+const BASELINE_RUNS = 20;
+// A pending row older than this is a lost one, not a slow run.
+const LOST_AFTER_MS = 24 * 60 * MIN;
+
+export function observeCi(
+  workspaceId: string,
+  facts: Pick<SessionFacts, "project" | "task">[],
+  now: number
+): void {
+  db.transaction(() => {
+    for (const f of facts) {
+      const pr = f.task?.pr;
+      const project = f.project;
+      if (!pr || !project) continue;
+      const head = pr.head;
+      if (pr.state !== "OPEN" || !head) {
+        db.prepare(
+          `DELETE FROM ci_runs WHERE project_id = ? AND pr_number = ?
+           AND settled_at IS NULL`
+        ).run(project, pr.number);
+        continue;
+      }
+      if (pr.checks === "pending") {
+        // A newer head replaces the run still pending on an older one.
+        db.prepare(
+          `DELETE FROM ci_runs WHERE project_id = ? AND pr_number = ?
+           AND head != ? AND settled_at IS NULL`
+        ).run(project, pr.number, head);
+        db.prepare(
+          `INSERT OR IGNORE INTO ci_runs
+             (project_id, workspace_id, pr_number, head, pending_since)
+           VALUES (?, ?, ?, ?, ?)`
+        ).run(project, workspaceId, pr.number, head, now);
+      } else if (pr.checks === "pass" || pr.checks === "fail") {
+        db.prepare(
+          `UPDATE ci_runs SET settled_at = ?
+           WHERE project_id = ? AND pr_number = ? AND head = ?
+           AND settled_at IS NULL`
+        ).run(now, project, pr.number, head);
+      }
+    }
+  })();
+}
+
+export function pendingCi(now: number): CiFact[] {
+  const rows = db
+    .prepare(
+      `SELECT * FROM ci_runs WHERE settled_at IS NULL AND pending_since >= ?`
+    )
+    .all(now - LOST_AFTER_MS) as {
+    project_id: string;
+    workspace_id: string | null;
+    pr_number: number;
+    head: string;
+    pending_since: number;
+  }[];
+  return rows.map((r) => ({
+    projectId: r.project_id,
+    workspaceId: r.workspace_id,
+    prNumber: r.pr_number,
+    head: r.head,
+    pendingSince: r.pending_since,
+    baseline: baseline(r.project_id),
+  }));
+}
+
+export function baseline(projectId: string): number[] {
+  return (
+    db
+      .prepare(
+        `SELECT settled_at - pending_since AS ms FROM ci_runs
+         WHERE project_id = ? AND settled_at IS NOT NULL
+         ORDER BY settled_at DESC LIMIT ?`
+      )
+      .all(projectId, BASELINE_RUNS) as { ms: number }[]
+  )
+    .map((r) => r.ms)
+    .filter((ms) => ms > 0);
+}