@saadnvd1/agent-os 0.3.616 → 0.3.624

package/components/Pane/MobileViewPicker.tsx

@@ -28,6 +28,8 @@ export interface MobileView {
 
 export interface MobileViewAvailability {
   isLocalSession: boolean;
+  // Local, and the folder is not known to be outside a git repository.
+  showGit: boolean;
   hasLog?: boolean;
   isConductor: boolean;
   workerCount: number;
@@ -36,6 +38,7 @@ export interface MobileViewAvailability {
 // The one list of views on a phone; the picker renders it.
 export function mobileViews({
   isLocalSession,
+  showGit,
   hasLog,
   isConductor,
   workerCount,
@@ -43,7 +46,7 @@ export function mobileViews({
   const views: (MobileView | false)[] = [
     { mode: "terminal", label: "Chat", icon: TerminalIcon },
     isLocalSession && { mode: "files", label: "Files", icon: FolderOpen },
-    isLocalSession && { mode: "git", label: "Git", icon: GitBranch },
+    showGit && { mode: "git", label: "Git", icon: GitBranch },
     { mode: "artifacts", label: "Artifacts", icon: Package },
     !!hasLog && { mode: "log", label: "Log", icon: ScrollText },
     isConductor && {

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

@@ -18,8 +18,12 @@ import type { ViewMode } from "@/contexts/PaneContext";
 
 interface PaneViewToggleProps {
   sessionId?: string;
+  // The session runs as a chat, so its main view is the chat, not a terminal.
+  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;
@@ -75,8 +79,10 @@ function ToggleButton({
 // session only gets the terminal (and workers).
 export function PaneViewToggle({
   sessionId,
+  isChat,
   viewMode,
   isLocalSession,
+  showGit,
   isConductor,
   hasLog,
   workerCount,
@@ -89,7 +95,7 @@ export function PaneViewToggle({
   return (
     <div className="bg-accent/50 flex shrink-0 items-center rounded-md p-0.5">
       <ToggleButton
-        label="Terminal"
+        label={isChat ? "Chat" : "Terminal"}
         active={viewMode === "terminal"}
         onClick={() => onViewModeChange("terminal")}
       >
@@ -104,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/components/views/DesktopAppActions.tsx

@@ -45,29 +45,35 @@ export function SidebarToggle({
   );
 }
 
-export function DesktopAppActions() {
+// A pinned sidebar has its own New button, so this one shows only while the
+// sidebar is hidden.
+export function DesktopAppActions({ showNew }: { showNew: boolean }) {
   return (
     <div
       className="flex shrink-0 items-center gap-0.5"
       onClick={(e) => e.stopPropagation()}
     >
       <InboxButton />
-      <Tooltip>
-        <TooltipTrigger asChild>
-          <Button
-            size="icon-sm"
-            aria-label="New session"
-            className="ml-1 h-7 w-7"
-            onClick={() => newDraft({ kind: "current" })}
-          >
-            <Plus className="h-4 w-4" />
-          </Button>
-        </TooltipTrigger>
-        <TooltipContent>
-          <p>New session</p>
-          <p className="text-muted-foreground text-xs">{DRAFT_KEYS.current}</p>
-        </TooltipContent>
-      </Tooltip>
+      {showNew && (
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button
+              size="icon-sm"
+              aria-label="New session"
+              className="ml-1 h-7 w-7"
+              onClick={() => newDraft({ kind: "current" })}
+            >
+              <Plus className="h-4 w-4" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent>
+            <p>New session</p>
+            <p className="text-muted-foreground text-xs">
+              {DRAFT_KEYS.current}
+            </p>
+          </TooltipContent>
+        </Tooltip>
+      )}
     </div>
   );
 }

package/components/views/DesktopView.tsx

@@ -59,7 +59,7 @@ export function DesktopView({
             leading={
               <SidebarToggle isPinned={isPinned} togglePin={togglePin} />
             }
-            trailing={<DesktopAppActions />}
+            trailing={<DesktopAppActions showNew={!isPinned} />}
           >
             <PaneLayout renderPane={renderPane} />
           </PaneBarSlotsProvider>

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/chat/pending.ts

@@ -1,4 +1,4 @@
-import type { ChatImage } from "./events";
+import type { ChatImage, ChatState } from "./events";
 
 // A message the composer sent that isn't in the chat or its queue yet. It
 // shows as a bubble at once, and stays (as failed, with Retry) if it never
@@ -113,6 +113,18 @@ export function pendingReducer(
   }
 }
 
+// A compact-first send reads "Compacting first" from the server accepting it
+// until compaction is over. The chat is idle in that gap (compaction starts
+// it running), so idle means it hasn't begun; running with no compaction
+// means it finished, or the server decided not to compact.
+export const compactsFirst = (
+  p: Pick<PendingSend, "status" | "compact">,
+  chat: { state: ChatState; compacting: unknown }
+) =>
+  !!p.compact &&
+  p.status === "accepted" &&
+  (!!chat.compacting || chat.state === "idle");
+
 // What a new socket sends again: anything not failed and not over its sends.
 // Safe to repeat: the server drops an id already in the chat or its queue.
 export const toResend = (state: PendingSend[]) =>

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;