@saadnvd1/agent-os 0.3.627 → 0.3.630

package/components/Chat/Messages.test.ts

@@ -93,3 +93,29 @@ describe("a sent message not in the chat yet", () => {
     expect(html).not.toContain("Not sent");
   });
 });
+
+describe("UserMessage code blocks", () => {
+  it("renders a fenced ts block with highlighted tokens, queued or sent", async () => {
+    const { PrismAsyncLight } = await import("react-syntax-highlighter");
+    const ts = (
+      await import("react-syntax-highlighter/dist/esm/languages/prism/typescript")
+    ).default;
+    await (
+      PrismAsyncLight as unknown as { preload: () => Promise<void> }
+    ).preload();
+    PrismAsyncLight.registerLanguage("typescript", ts);
+    const user = {
+      id: "u1",
+      kind: "user",
+      text: "try:\n\n```ts\nconst x: number = 1;\n```\n\nthanks",
+    } as never;
+    for (const pending of [undefined, { status: "sending" } as never]) {
+      const html = renderToStaticMarkup(
+        createElement(UserMessage, { item: user, pending })
+      );
+      expect(html).toMatch(/style="color:[^"]*">const<\/span>/);
+      expect(html).toContain("number");
+      expect(html).not.toContain("```");
+    }
+  });
+});

package/components/Chat/composer/ComposerBody.tsx

@@ -16,6 +16,7 @@ import {
   type TextAttachment,
 } from "@/lib/chat/paste";
 import { insertCommand, rankCommands, slashQuery } from "@/lib/chat/commands";
+import { mentionOption } from "@/lib/chat/mentions";
 import { cn } from "@/lib/utils";
 import { loadDraft, useSaveDraft } from "../useDraft";
 import { ComposerMenu, type MenuOption } from "../ComposerMenu";
@@ -189,10 +190,7 @@ export function ComposerBody({
       : mentions.files.map((f) => ({
           key: `${f.dir ? "d" : "f"}:${f.path}`,
           // The name first, so two long paths never read the same.
-          label: `${f.path.slice(f.path.lastIndexOf("/") + 1)}${f.dir ? "/" : ""}`,
-          hint: f.path.includes("/")
-            ? f.path.slice(0, f.path.lastIndexOf("/"))
-            : undefined,
+          ...mentionOption(f),
           icon: f.dir ? (
             <Folder className="text-muted-foreground h-3.5 w-3.5 shrink-0" />
           ) : (

package/components/SessionList/LoadGauge.test.ts

@@ -0,0 +1,89 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { healthKeys } from "@/data/health";
+import { loadKeys } from "@/data/load";
+import type { LoadView } from "@/lib/load/monitor";
+import { settingsUi } from "@/stores/settingsUi";
+import { LoadGauge } from "./LoadGauge";
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+let host: HTMLElement;
+let root: Root;
+beforeEach(() => {
+  host = document.createElement("div");
+  document.body.append(host);
+  root = createRoot(host);
+  settingsUi.open = false;
+  settingsUi.section = null;
+  vi.stubGlobal("fetch", () => new Promise(() => {}));
+});
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+  vi.unstubAllGlobals();
+});
+
+const view = (level: LoadView["level"]): LoadView => ({
+  level,
+  load1: 1,
+  cores: 8,
+  memUsedPct: 30,
+  pressure: "normal",
+  top: [],
+  unattributed: [],
+  sessions: {},
+});
+
+function render(
+  level: LoadView["level"],
+  health: { open: number; needsYou: number }
+) {
+  const qc = new QueryClient({
+    defaultOptions: { queries: { retry: false, staleTime: Infinity } },
+  });
+  qc.setQueryData(loadKeys.all, view(level));
+  qc.setQueryData(healthKeys.count(), health);
+  act(() =>
+    root.render(
+      createElement(
+        QueryClientProvider,
+        { client: qc },
+        createElement(LoadGauge)
+      )
+    )
+  );
+}
+
+describe("LoadGauge", () => {
+  it("renders one dot, never a separate health dot", () => {
+    render("green", { open: 1, needsYou: 0 });
+    expect(host.querySelectorAll("button")).toHaveLength(1);
+    expect(host.querySelector("[data-health-dot]")).toBeNull();
+  });
+
+  it("opens Settings → Health when an issue is open", () => {
+    render("green", { open: 1, needsYou: 0 });
+    const b = host.querySelector("button")!;
+    expect(b.dataset.statusDot).toBe("amber");
+    expect(b.getAttribute("aria-label")).toBe(
+      "Load normal · 1 health issue open"
+    );
+    act(() => b.click());
+    expect(settingsUi.open).toBe(true);
+    expect(settingsUi.section).toBe("health");
+  });
+
+  it("keeps the load popover when nothing is open", () => {
+    render("red", { open: 0, needsYou: 0 });
+    const b = host.querySelector("button")!;
+    expect(b.dataset.statusDot).toBe("red");
+    expect(b.dataset.opens).toBe("load");
+    expect(b.getAttribute("aria-haspopup")).toBe("menu");
+  });
+});

package/components/SessionList/LoadGauge.tsx

@@ -6,42 +6,51 @@ import {
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
 import { Button } from "@/components/ui/button";
+import { useHealthCount } from "@/data/health";
 import { usageLabel, useMachineLoad } from "@/data/load";
-import type { LoadView } from "@/lib/load/monitor";
+import { settingsUiActions } from "@/stores/settingsUi";
+import { loadSummary, statusDot, type DotLevel } from "./statusDot";
 import { cn } from "@/lib/utils";
 
-const DOT: Record<LoadView["level"], string> = {
+const DOT: Record<DotLevel, string> = {
   green: "bg-green-500",
   amber: "bg-amber-500",
   red: "bg-destructive",
 };
 
-// "Load 4.2 on 10 cores · memory normal"
-export function loadSummary(load: LoadView): string {
-  const memory = load.pressure ?? `${load.memUsedPct}% used`;
-  return `Load ${load.load1} on ${load.cores} cores · memory ${memory}`;
-}
+const BUTTON_CLASS =
+  "-ml-1.5 h-11 w-11 shrink-0 md:ml-0 md:h-8 md:w-6 [@media(hover:none)]:md:-ml-1.5 [@media(hover:none)]:md:h-11 [@media(hover:none)]:md:w-11";
 
-// The machine's load as a dot beside the workspace's name; tap it for the
-// numbers and the sessions using the most CPU.
+// One dot beside the workspace's name for the machine's load and the health
+// watch, whichever is worse. With a health issue open a tap goes to Settings
+// → Health; otherwise it shows the load numbers and the busiest sessions.
 export function LoadGauge() {
   const load = useMachineLoad();
-  if (!load) return null;
+  const { data: health } = useHealthCount();
+  const dot = statusDot(load, health);
+  if (!dot) return null;
+  const button = (
+    <Button
+      variant="ghost"
+      size="icon-sm"
+      aria-label={dot.label}
+      title={dot.title}
+      data-status-dot={dot.level}
+      data-opens={dot.opensHealth ? "health" : "load"}
+      onClick={
+        dot.opensHealth ? () => settingsUiActions.open("health") : undefined
+      }
+      className={BUTTON_CLASS}
+    >
+      <span className={cn("h-2 w-2 rounded-full", DOT[dot.level])} />
+    </Button>
+  );
+  if (dot.opensHealth || !load) return button;
   const summary = loadSummary(load);
   const top = load.top.filter((s) => s.cores >= 0.1);
   return (
     <DropdownMenu>
-      <DropdownMenuTrigger asChild>
-        <Button
-          variant="ghost"
-          size="icon-sm"
-          aria-label={`Machine load ${load.level}. ${summary}`}
-          title={summary}
-          className="-ml-1.5 h-11 w-11 shrink-0 md:ml-0 md:h-8 md:w-6 [@media(hover:none)]:md:-ml-1.5 [@media(hover:none)]:md:h-11 [@media(hover:none)]:md:w-11"
-        >
-          <span className={cn("h-2 w-2 rounded-full", DOT[load.level])} />
-        </Button>
-      </DropdownMenuTrigger>
+      <DropdownMenuTrigger asChild>{button}</DropdownMenuTrigger>
       <DropdownMenuContent align="end" className="w-72 p-3">
         <p className="text-sm font-medium">{summary}</p>
         {load.level !== "green" && (

package/components/SessionList/SidebarHeader.tsx

@@ -39,7 +39,6 @@ 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";
@@ -72,7 +71,6 @@ 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/SessionList/statusDot.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import type { LoadView } from "@/lib/load/monitor";
+import { statusDot } from "./statusDot";
+
+const load = (level: LoadView["level"]): LoadView => ({
+  level,
+  load1: 4.2,
+  cores: 10,
+  memUsedPct: 40,
+  pressure: "normal",
+  top: [],
+  unattributed: [],
+  sessions: {},
+});
+const none = { open: 0, needsYou: 0 };
+
+describe("statusDot", () => {
+  it("is green and opens the load popover when all is well", () => {
+    const d = statusDot(load("green"), none)!;
+    expect(d).toMatchObject({
+      level: "green",
+      label: "Load normal",
+      opensHealth: false,
+      healthLine: null,
+    });
+  });
+  it("follows load alone", () => {
+    expect(statusDot(load("amber"), none)!.level).toBe("amber");
+    expect(statusDot(load("red"), none)!.level).toBe("red");
+  });
+  it("goes amber for an open health issue and opens Health", () => {
+    const d = statusDot(load("green"), { open: 1, needsYou: 0 })!;
+    expect(d.level).toBe("amber");
+    expect(d.label).toBe("Load normal · 1 health issue open");
+    expect(d.title).toContain("Load 4.2 on 10 cores");
+    expect(d.opensHealth).toBe(true);
+  });
+  it("goes red when a health issue needs Saad", () => {
+    const d = statusDot(load("green"), { open: 2, needsYou: 2 })!;
+    expect(d.level).toBe("red");
+    expect(d.label).toBe("Load normal · 2 health issues need you");
+    expect(statusDot(load("amber"), { open: 1, needsYou: 1 })!.level).toBe(
+      "red"
+    );
+  });
+  it("takes the worse of the two", () => {
+    expect(statusDot(load("red"), { open: 1, needsYou: 0 })!.level).toBe("red");
+  });
+  it("shows health alone before load arrives, nothing with neither", () => {
+    expect(statusDot(null, { open: 2, needsYou: 0 })!.label).toBe(
+      "2 health issues open"
+    );
+    expect(statusDot(null, none)).toBeNull();
+    expect(statusDot(null, undefined)).toBeNull();
+  });
+});

package/components/SessionList/statusDot.ts

@@ -0,0 +1,59 @@
+import type { LoadView } from "@/lib/load/monitor";
+
+export type DotLevel = "green" | "amber" | "red";
+export interface HealthCount {
+  open: number;
+  needsYou: number;
+}
+
+export interface StatusDot {
+  level: DotLevel;
+  label: string;
+  title: string;
+  healthLine: string | null;
+  opensHealth: boolean;
+}
+
+const WORD: Record<LoadView["level"], string> = {
+  green: "normal",
+  amber: "busy",
+  red: "high",
+};
+
+// "Load 4.2 on 10 cores · memory normal"
+export function loadSummary(load: LoadView): string {
+  const memory = load.pressure ?? `${load.memUsedPct}% used`;
+  return `Load ${load.load1} on ${load.cores} cores · memory ${memory}`;
+}
+
+export function healthLine(h: HealthCount | undefined): string | null {
+  if (!h) return null;
+  if (h.needsYou > 0)
+    return `${h.needsYou} health issue${h.needsYou === 1 ? " needs" : "s need"} you`;
+  if (h.open > 0)
+    return `${h.open} health issue${h.open === 1 ? "" : "s"} open`;
+  return null;
+}
+
+// One dot for the machine load and the health watch: the worse of the two.
+export function statusDot(
+  load: LoadView | null,
+  health: HealthCount | undefined
+): StatusDot | null {
+  const line = healthLine(health);
+  if (!load && !line) return null;
+  const level: DotLevel =
+    load?.level === "red" || (health?.needsYou ?? 0) > 0
+      ? "red"
+      : load?.level === "amber" || (health?.open ?? 0) > 0
+        ? "amber"
+        : "green";
+  const join = (parts: (string | null)[]) => parts.filter(Boolean).join(" · ");
+  return {
+    level,
+    label: join([load ? `Load ${WORD[load.level]}` : null, line]),
+    title: join([load ? loadSummary(load) : null, line]),
+    healthLine: line,
+    opensHealth: (health?.open ?? 0) > 0,
+  };
+}

package/data/health/index.ts

@@ -34,7 +34,7 @@ export function useHealthQuery() {
   });
 }
 
-// What the sidebar dot needs, and nothing more.
+// What the sidebar status dot needs, and nothing more.
 export function useHealthCount() {
   return useQuery({
     queryKey: healthKeys.count(),

package/lib/chat/events.ts

@@ -273,6 +273,11 @@ export interface QueuedMessage {
 export interface FileSuggestion {
   path: string;
   dir: boolean;
+  // An orchestrator's picker searches several folders: `path` is then
+  // absolute, `source` names the folder it came from ("HQ", a project) and
+  // `rel` is the path inside it.
+  source?: string;
+  rel?: string;
 }
 
 // Waiting: a turn is paused on the reader (an approval or a question).

package/lib/chat/files.ts

@@ -1,12 +1,18 @@
 import { execFile } from "child_process";
+import fs from "fs";
+import path from "path";
 import { promisify } from "util";
 import { git } from "../git-exec";
+import { isSecretPath } from "../secret-paths";
 import type { FileSuggestion } from "./events";
 import {
+  ahead,
   indexPaths,
   rankPaths,
+  scanPaths,
   withFolders,
   type IndexedPath,
+  type Scored,
 } from "./mentions";
 
 const execFileAsync = promisify(execFile);
@@ -26,13 +32,23 @@ let sweeper: ReturnType<typeof setInterval> | null = null;
 export function sweepFileIndexes(now = Date.now()): void {
   for (const [cwd, hit] of cache)
     if (now - hit.usedAt > IDLE_MS) cache.delete(cwd);
-  if (!cache.size && sweeper) {
+  for (const [key, hit] of roots)
+    if (now - hit.usedAt > IDLE_MS) roots.delete(key);
+  for (const [key, hit] of narrowing)
+    if (now - hit.at > NARROW_MS) narrowing.delete(key);
+  if (!cache.size && !roots.size && !narrowing.size && sweeper) {
     clearInterval(sweeper);
     sweeper = null;
   }
 }
 
-export const fileIndexCount = () => cache.size;
+export const fileIndexCount = () => cache.size + roots.size;
+
+function keepSweeping() {
+  if (sweeper) return;
+  sweeper = setInterval(() => sweepFileIndexes(), 60_000);
+  sweeper.unref?.();
+}
 
 const LIST_TIMEOUT_MS = 5000;
 
@@ -40,21 +56,26 @@ export interface Lister {
   // The program it needs.
   cmd: string;
   list: (cwd: string) => Promise<string>;
+  // The same, newest first, where the program can.
+  recent?: (cwd: string) => Promise<string>;
 }
 
+const rgFiles = async (cwd: string, extra: string[]) =>
+  (
+    await execFileAsync(
+      "rg",
+      ["--files", "--hidden", "-g", "!.git", ...extra],
+      { cwd, maxBuffer: 64 * 1024 * 1024, timeout: LIST_TIMEOUT_MS }
+    )
+  ).stdout;
+
 // Ways to list a folder's files with ignored ones left out: ripgrep, or
 // git where ripgrep isn't installed.
 export const LISTERS: Lister[] = [
   {
     cmd: "rg",
-    list: async (cwd) =>
-      (
-        await execFileAsync("rg", ["--files", "--hidden", "-g", "!.git"], {
-          cwd,
-          maxBuffer: 64 * 1024 * 1024,
-          timeout: LIST_TIMEOUT_MS,
-        })
-      ).stdout,
+    list: (cwd) => rgFiles(cwd, []),
+    recent: (cwd) => rgFiles(cwd, ["--sortr", "modified"]),
   },
   {
     cmd: "git",
@@ -66,18 +87,30 @@ export const LISTERS: Lister[] = [
   },
 ];
 
+// How many of the newest files get their modified time read: enough for a
+// "what did I just touch" list, few enough to cost milliseconds.
+const RECENT_STATS = 200;
+
 // The folder's files, for @mentions when no agent is running to match them
-// itself. Empty when neither tool can list it.
+// itself. Empty when neither tool can list it. Secret files (env files, keys)
+// are left out. With `recent`, the newest files carry their modified time.
 export async function listFiles(
   cwd: string,
-  listers = LISTERS
+  listers = LISTERS,
+  recent = false
 ): Promise<IndexedPath[]> {
-  for (const { list } of listers) {
+  for (const lister of listers) {
+    const newestFirst = recent && lister.recent;
     try {
-      const stdout = await list(cwd);
-      return indexPaths(
-        withFolders(stdout.split("\n").filter(Boolean).slice(0, MAX_FILES))
-      );
+      const stdout = await (newestFirst ? lister.recent! : lister.list)(cwd);
+      const paths = stdout
+        .split("\n")
+        .filter((p) => p && !isSecretPath(p))
+        .slice(0, MAX_FILES);
+      const indexed = indexPaths(withFolders(paths));
+      if (newestFirst)
+        stamp(indexed, await modifiedTimes(cwd, paths.slice(0, RECENT_STATS)));
+      return indexed;
     } catch {
       // Not installed, or not a repository: try the next.
     }
@@ -85,6 +118,38 @@ export async function listFiles(
   return [];
 }
 
+// Modified times of these files, and of the folders above them (the newest
+// thing inside).
+async function modifiedTimes(
+  cwd: string,
+  paths: string[]
+): Promise<Map<string, number>> {
+  const times = new Map<string, number>();
+  await Promise.all(
+    paths.map(async (p) => {
+      let mtime: number;
+      try {
+        mtime = (await fs.promises.stat(path.join(cwd, p))).mtimeMs;
+      } catch {
+        return;
+      }
+      times.set(p, mtime);
+      for (let i = p.lastIndexOf("/"); i > 0; i = p.lastIndexOf("/", i - 1)) {
+        const dir = p.slice(0, i);
+        if ((times.get(dir) ?? 0) < mtime) times.set(dir, mtime);
+      }
+    })
+  );
+  return times;
+}
+
+function stamp(indexed: IndexedPath[], times: Map<string, number>) {
+  for (const p of indexed) {
+    const mtime = times.get(p.file.path);
+    if (mtime !== undefined) p.mtime = mtime;
+  }
+}
+
 export async function fallbackFileSuggestions(
   cwd: string,
   query: string
@@ -96,9 +161,140 @@ export async function fallbackFileSuggestions(
     cache.set(cwd, hit);
   }
   hit.usedAt = now;
-  if (!sweeper) {
-    sweeper = setInterval(() => sweepFileIndexes(), 60_000);
-    sweeper.unref?.();
-  }
+  keepSweeping();
   return rankPaths(query, await hit.files);
 }
+
+// ---- An orchestrator's "@": HQ and the project repositories ----
+
+// An orchestrator works through tools, not in a folder, so its picker
+// searches the places the workspace lives in instead.
+export interface MentionRoot {
+  dir: string;
+  // "HQ", a project's name: what the menu shows beside the path.
+  label: string;
+  // HQ wins ties with the repositories.
+  hq: boolean;
+}
+
+const ROOT_TTL_MS = 60_000;
+// A cold "@" answers from the folders listed by now rather than wait for
+// the slowest repository.
+const READY_MS = 120;
+const HQ_BOOST = 5;
+// A query's matches are kept this long for the next keystroke to narrow.
+const NARROW_MS = 30_000;
+
+interface RootEntry {
+  at: number;
+  usedAt: number;
+  // The last finished listing, answered from while the next is built.
+  list: IndexedPath[] | null;
+  building: Promise<IndexedPath[]> | null;
+}
+const roots = new Map<string, RootEntry>();
+
+// The roots' files as the menu shows them: absolute paths with their
+// source, each root's own folder first, so "@agent" finds the repository.
+async function buildRoot(root: MentionRoot): Promise<IndexedPath[]> {
+  const listed = await listFiles(root.dir, LISTERS, true);
+  const self: IndexedPath = {
+    file: { path: root.dir, dir: true, source: root.label, rel: "" },
+    lower: root.label.toLowerCase(),
+    name: root.label.toLowerCase(),
+    depth: 0,
+  };
+  return [
+    self,
+    ...listed.map((p) => ({
+      ...p,
+      file: {
+        path: path.join(root.dir, p.file.path),
+        dir: p.file.dir,
+        source: root.label,
+        rel: p.file.path,
+      },
+    })),
+  ];
+}
+
+function rootEntry(root: MentionRoot): RootEntry {
+  const key = `${root.label}\0${root.dir}`;
+  const now = Date.now();
+  let hit = roots.get(key);
+  if (!hit) {
+    hit = { at: now, usedAt: now, list: null, building: null };
+    roots.set(key, hit);
+  }
+  hit.usedAt = now;
+  if (!hit.building && (!hit.list || now - hit.at > ROOT_TTL_MS)) {
+    const entry = hit;
+    entry.building = buildRoot(root)
+      .catch(() => [] as IndexedPath[])
+      .then((list) => {
+        entry.list = list;
+        entry.at = Date.now();
+        entry.building = null;
+        return list;
+      });
+  }
+  keepSweeping();
+  return hit;
+}
+
+// Starts listing the roots, so the first "@" finds them built.
+export function warmFileIndexes(rootList: MentionRoot[]): void {
+  for (const root of rootList) rootEntry(root);
+}
+
+// What the last query kept per root, for the next to narrow.
+const narrowing = new Map<
+  string,
+  { query: string; at: number; kept: Map<IndexedPath[], IndexedPath[]> }
+>();
+
+export async function multiRootFileSuggestions(
+  rootList: MentionRoot[],
+  query: string,
+  // Whose keystrokes these are: what one query matched narrows the next.
+  key = "",
+  stats?: { scanned: number }
+): Promise<FileSuggestion[]> {
+  const entries = rootList.map(rootEntry);
+  const pending = entries.flatMap((e) =>
+    e.list || !e.building ? [] : [e.building]
+  );
+  if (pending.length) {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    await Promise.race([
+      Promise.all(pending),
+      new Promise((resolve) => (timer = setTimeout(resolve, READY_MS))),
+    ]);
+    clearTimeout(timer);
+  }
+
+  const q = query.toLowerCase();
+  const prev = key ? narrowing.get(key) : undefined;
+  const narrower = !!prev && prev.query !== "" && q.startsWith(prev.query);
+  const kept = new Map<IndexedPath[], IndexedPath[]>();
+  const tops: Scored[] = [];
+  entries.forEach((entry, i) => {
+    const list = entry.list;
+    if (!list) return;
+    const from = (narrower && prev!.kept.get(list)) || list;
+    const scan = scanPaths(q, from, {
+      keep: q !== "",
+      boost: rootList[i].hq ? HQ_BOOST : 0,
+    });
+    if (stats) stats.scanned += scan.scanned;
+    if (scan.matches) kept.set(list, scan.matches);
+    tops.push(...scan.top);
+  });
+  if (key && q) narrowing.set(key, { query: q, at: Date.now(), kept });
+  else if (key) narrowing.delete(key);
+  keepSweeping();
+  return tops
+    .sort((a, b) => (ahead(a, b) ? -1 : ahead(b, a) ? 1 : 0))
+    .slice(0, 15)
+    .map((x) => x.p.file);
+}

package/lib/chat/mention-roots.ts

@@ -0,0 +1,80 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { db } from "../db";
+import { getHq } from "../session-logs/hq";
+import { expand, repoPaths, resolved } from "../session-logs/paths";
+import type { MentionRoot } from "./files";
+
+// HQ and seven repositories: more than a workspace has, and a bound on
+// what an "@" indexes.
+const MAX_ROOTS = 8;
+
+function isFolder(dir: string): boolean {
+  try {
+    return fs.statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// Where an orchestrator's "@" looks: the workspace's HQ, then each local
+// project's repositories. Null for any other session, whose picker keeps
+// searching its own folder. The orchestrator's scratch folder holds its own
+// working notes, not what's pointed at, so it's searched only when nothing
+// else is there.
+export function mentionRoots(sessionId: string): MentionRoot[] | null {
+  const session = db
+    .prepare(
+      `SELECT role, workspace_id, working_directory FROM sessions WHERE id = ?`
+    )
+    .get(sessionId) as
+    | {
+        role: string | null;
+        workspace_id: string | null;
+        working_directory: string;
+      }
+    | undefined;
+  if (session?.role !== "orchestrator") return null;
+
+  // Never the home folder or the whole disk: a project pointed there would
+  // list everything under it, dotfiles and keys included.
+  const refused = new Set([
+    path.parse(os.homedir()).root,
+    resolved(os.homedir()),
+  ]);
+  const found: MentionRoot[] = [];
+  const add = (dir: string, label: string, hq: boolean, needsGit = false) => {
+    if (found.length >= MAX_ROOTS || refused.has(dir) || !isFolder(dir)) return;
+    if (needsGit && !fs.existsSync(path.join(dir, ".git"))) return;
+    if (found.some((r) => r.dir === dir)) return;
+    const taken = found.some((r) => r.label === label);
+    found.push({
+      dir,
+      label: taken ? `${label}/${path.basename(dir)}` : label,
+      hq,
+    });
+  };
+
+  const workspaceId = session.workspace_id;
+  if (workspaceId) {
+    const hq = getHq(workspaceId);
+    if (hq) add(resolved(expand(hq.folder)), "HQ", true, true);
+    const projects = db
+      .prepare(
+        `SELECT id, name FROM projects
+         WHERE workspace_id = ? AND host_id = 'local' AND is_uncategorized = 0
+         ORDER BY sort_order, name`
+      )
+      .all(workspaceId) as { id: string; name: string }[];
+    for (const project of projects)
+      repoPaths(project.id).forEach((dir, i) =>
+        add(dir, i === 0 ? project.name : path.basename(dir), false)
+      );
+  }
+  if (!found.length) {
+    const scratch = resolved(expand(session.working_directory));
+    return [{ dir: scratch, label: "scratch", hq: false }];
+  }
+  return found;
+}

package/lib/chat/mentions.ts

@@ -37,6 +37,9 @@ export interface IndexedPath {
   lower: string;
   name: string;
   depth: number;
+  // Modified time in ms, where the index knows it: newer ranks first among
+  // equal matches.
+  mtime?: number;
 }
 
 export function indexPaths(files: FileSuggestion[]): IndexedPath[] {
@@ -68,16 +71,48 @@ function score(q: string, p: IndexedPath): number {
   return 10;
 }
 
-// Ahead of b: a better score, then a shallower path, then alphabetical.
-const ahead = (
-  a: { s: number; p: IndexedPath },
-  b: { s: number; p: IndexedPath }
-) =>
+// Ahead of b: a better score, then the more recently modified, then a
+// shallower path, then alphabetical.
+export interface Scored {
+  s: number;
+  p: IndexedPath;
+}
+export const ahead = (a: Scored, b: Scored) =>
   a.s !== b.s
     ? a.s > b.s
-    : a.p.depth !== b.p.depth
-      ? a.p.depth < b.p.depth
-      : a.p.lower < b.p.lower;
+    : (a.p.mtime ?? 0) !== (b.p.mtime ?? 0)
+      ? (a.p.mtime ?? 0) > (b.p.mtime ?? 0)
+      : a.p.depth !== b.p.depth
+        ? a.p.depth < b.p.depth
+        : a.p.lower < b.p.lower;
+
+// One pass over an index: the best `limit` matches, best first, how many
+// entries were looked at, and (when asked) every entry that matched, so the
+// next keystroke of the same query can look at those alone: whatever
+// matches "fil" also matches "file". `boost` raises every score of a folder
+// that should win ties, not for an empty query where recency is the point.
+export function scanPaths(
+  query: string,
+  indexed: IndexedPath[],
+  opts: { limit?: number; keep?: boolean; boost?: number } = {}
+): { top: Scored[]; matches: IndexedPath[] | null; scanned: number } {
+  const limit = opts.limit ?? 15;
+  const boost = query ? (opts.boost ?? 0) : 0;
+  const top: Scored[] = [];
+  const matches: IndexedPath[] | null = opts.keep ? [] : null;
+  for (const p of indexed) {
+    const raw = score(query, p);
+    if (raw === 0) continue;
+    matches?.push(p);
+    const x = { s: raw + boost, p };
+    if (top.length === limit && !ahead(x, top[top.length - 1])) continue;
+    let i = top.length;
+    while (i > 0 && ahead(x, top[i - 1])) i--;
+    top.splice(i, 0, x);
+    if (top.length > limit) top.pop();
+  }
+  return { top, matches, scanned: indexed.length };
+}
 
 // Best matches first, then shorter paths; for when the agent can't be asked.
 // Keeps only the top few as it goes: a folder can hold tens of thousands of
@@ -87,23 +122,32 @@ export function rankPaths(
   files: FileSuggestion[] | IndexedPath[],
   limit = 15
 ): FileSuggestion[] {
-  const q = query.toLowerCase();
   const indexed =
     files.length && "lower" in files[0]
       ? (files as IndexedPath[])
       : indexPaths(files as FileSuggestion[]);
-  const top: { s: number; p: IndexedPath }[] = [];
-  for (const p of indexed) {
-    const s = score(q, p);
-    if (s === 0) continue;
-    const x = { s, p };
-    if (top.length === limit && !ahead(x, top[top.length - 1])) continue;
-    let i = top.length;
-    while (i > 0 && ahead(x, top[i - 1])) i--;
-    top.splice(i, 0, x);
-    if (top.length > limit) top.pop();
-  }
-  return top.map((x) => x.p.file);
+  return scanPaths(query.toLowerCase(), indexed, { limit }).top.map(
+    (x) => x.p.file
+  );
+}
+
+// How a suggestion reads in the "@" menu: its name, and where it lives. An
+// orchestrator's results lead the hint with their source ("HQ · docs").
+export function mentionOption(f: FileSuggestion): {
+  label: string;
+  hint?: string;
+} {
+  const label = `${f.path.slice(f.path.lastIndexOf("/") + 1)}${f.dir ? "/" : ""}`;
+  if (f.source === undefined)
+    return {
+      label,
+      hint: f.path.includes("/")
+        ? f.path.slice(0, f.path.lastIndexOf("/"))
+        : undefined,
+    };
+  const rel = f.rel ?? "";
+  const parent = rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : "";
+  return { label, hint: parent ? `${f.source} · ${parent}` : f.source };
 }
 
 // Every folder a file list implies, alongside the files themselves.

package/lib/chat/runner.ts

@@ -60,7 +60,12 @@ import {
   moveQueued,
   queuedSessions,
 } from "./queued";
-import { fallbackFileSuggestions } from "./files";
+import {
+  fallbackFileSuggestions,
+  multiRootFileSuggestions,
+  warmFileIndexes,
+} from "./files";
+import { mentionRoots } from "./mention-roots";
 import { REQUESTED_FRESH, releaseConversation } from "./refresh";
 import { holdsQueue, settingUp } from "../sessions/setup-progress";
 import { firstMessageId, launchPending } from "../tasks/launch-gate";
@@ -631,12 +636,22 @@ export async function sendQueuedNow(
   live.worker.command({ type: "send_now", id, during });
 }
 
-// Files and folders for an @mention: the agent's own matching when its
-// worker is up and has an answer, ripgrep over the folder otherwise.
+// An orchestrator's "@" index starts building when its chat opens.
+export function warmChatFileIndexes(sessionId: string): void {
+  const roots = mentionRoots(sessionId);
+  if (roots) warmFileIndexes(roots);
+}
+
+// Files and folders for an @mention: an orchestrator's come from its HQ and
+// project repositories (the agent only sees its scratch folder); any other
+// session's from the agent's own matching when its worker is up and has an
+// answer, ripgrep over the folder otherwise.
 export async function chatFileSuggestions(
   sessionId: string,
   query: string
 ): Promise<FileSuggestion[]> {
+  const roots = mentionRoots(sessionId);
+  if (roots) return multiRootFileSuggestions(roots, query, sessionId);
   const live = registry.live.get(sessionId);
   const fromAgent = live?.canQueue
     ? await live.worker.fileSuggestions(query)

package/lib/chat/socket.ts

@@ -11,6 +11,7 @@ import { db } from "../db";
 import {
   carryOutPlan,
   chatFileSuggestions,
+  warmChatFileIndexes,
   chatHistory,
   backgroundChatTask,
   chatTaskOutput,
@@ -113,6 +114,7 @@ export function serveChatSocket(
   }
   try {
     unwatch = watchChat(sessionId, reply);
+    if (!demo) warmChatFileIndexes(sessionId);
   } catch (err) {
     fail(err);
     if (!closed) ws.close();

package/lib/chat/user-text.ts

@@ -44,7 +44,20 @@ export function splitUserText(text: string): UserTextPart[] {
   if (code !== null)
     parts.push({ kind: "code", code: code.join("\n"), language });
   flushProse();
-  return parts;
+  // A block carries its own margin: the line breaks around it would show as
+  // blank lines on top of that, in a bubble that keeps its line breaks.
+  return parts
+    .map((p, i) =>
+      p.kind === "text"
+        ? {
+            ...p,
+            text: p.text
+              .replace(parts[i - 1]?.kind === "code" ? /^\n+/ : /^$/, "")
+              .replace(parts[i + 1]?.kind === "code" ? /\n+$/ : /^$/, ""),
+          }
+        : p
+    )
+    .filter((p) => p.kind === "code" || p.text !== "");
 }
 
 // Backtick spans inside prose, split out so they can be set in monospace.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.627",
+  "version": "0.3.630",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/components/Health/HealthDot.tsx

@@ -1,35 +0,0 @@
-"use client";
-
-import { Button } from "@/components/ui/button";
-import { useHealthCount } from "@/data/health";
-import { settingsUiActions } from "@/stores/settingsUi";
-import { cn } from "@/lib/utils";
-
-// Beside the load gauge: shown only while something is open. Amber for an
-// anomaly, red when it needs the person. A tap opens Settings → Health.
-export function HealthDot() {
-  const { data } = useHealthCount();
-  if (!data || data.open === 0) return null;
-  const urgent = data.needsYou > 0;
-  const label = urgent
-    ? `${data.needsYou} health issue${data.needsYou === 1 ? "" : "s"} need you`
-    : `${data.open} health issue${data.open === 1 ? "" : "s"} open`;
-  return (
-    <Button
-      variant="ghost"
-      size="icon-sm"
-      aria-label={label}
-      title={label}
-      data-health-dot={urgent ? "red" : "amber"}
-      onClick={() => settingsUiActions.open("health")}
-      className="h-11 w-11 shrink-0 md:h-8 md:w-6 [@media(hover:none)]:md:h-11 [@media(hover:none)]:md:w-11"
-    >
-      <span
-        className={cn(
-          "h-2 w-2 rounded-sm",
-          urgent ? "bg-destructive" : "bg-amber-500"
-        )}
-      />
-    </Button>
-  );
-}