@saadnvd1/agent-os 0.3.673 → 0.3.680

package/README.md

@@ -22,6 +22,7 @@ and check on all of it from your phone.
 - **Agents that talk to each other.** Sessions message each other with `aos`, and you see every conversation in Messages. [More](docs/guides/agent-network.md)
 - **Chat or terminal, same conversation.** Streaming replies, steps and diffs, plan mode, slash commands, `@file`, undo. [More](docs/guides/chat.md)
 - **Bookmarks.** Star any message, tool call or turn, then find it again from the chat or across every chat, with a search. [More](docs/guides/chat.md)
+- **Search every conversation.** ⌘K (Ctrl+K off a Mac), then Tab: what you and your agents said in any chat, found as you type from a full-text index (a word's start matches, quotes match a phrase), with the message and its neighbours shown beside the results and a jump to it in the chat. Done, dropped and archived chats are included. [More](docs/reference/conversation-search.md)
 - **Every artifact in one place.** A session's plan, PR, files, pages, images and job logs in one list, with a preview, kept after its worktree is removed. [More](docs/guides/sessions.md#artifacts)
 - **Share a chat or a page.** A read-only snapshot link with secrets, home paths and machine names masked, a preview before anything leaves your machine, and a Markdown copy to hand to an agent. [More](docs/guides/sharing.md)
 - **Project config.** `agentos.json` gives each session its own ports, environment, files and a private Postgres copy. [More](docs/reference/project-config.md)
@@ -33,7 +34,7 @@ and check on all of it from your phone.
 - **LumifyHub (optional).** Boards, cards and docs for a workspace, if you want them. [More](docs/lumifyhub.md)
 - **No approvals mode.** One switch in Settings that approves every ask, lets brakes and plan-only tasks through, and starts every agent with its permission prompts off; each approval it makes is logged. Off by default. [More](docs/reference/orchestrator.md#no-approvals-mode)
 - **Experiments.** Settings → Experiments lists features still being tried, each off until you turn it on, with what it has cost and how often its suggestions were taken. The first is Learning cards: when a session ends it can offer to save the work as a recipe or keep a lesson where it belongs. [More](docs/decisions/2026-10-13-experiments.md)
-- **Also:** a ⌘K palette, code search, a file picker, a git panel, dev servers, up to four panes, and dictation.
+- **Also:** a ⌘K palette (actions, sessions, conversations), code search, a file picker, a git panel, dev servers, up to four panes, and dictation.
 
 ## Documentation
 

package/app/api/bus/read/route.ts

@@ -0,0 +1,34 @@
+import { NextRequest, NextResponse } from "next/server";
+import { ReadError, readPeer } from "@/lib/bus/read";
+
+// `aos read <session>`: a peer's conversation in the caller's workspace,
+// condensed. Read-only: nothing about the target changes.
+export async function GET(request: NextRequest) {
+  const q = request.nextUrl.searchParams;
+  const count = (k: string) => {
+    const raw = q.get(k);
+    if (raw === null) return undefined;
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 1 || n > 5000)
+      throw new ReadError(`${k} must be a whole number from 1 to 5000`, 400);
+    return n;
+  };
+  try {
+    const from = q.get("from");
+    if (!from)
+      throw new ReadError("aos read runs from inside an AgentOS session", 400);
+    const result = await readPeer(from, q.get("ref") ?? "", {
+      turns: count("turns"),
+      lines: count("lines"),
+      all: q.get("all") === "1",
+      grep: q.get("grep") || undefined,
+    });
+    return NextResponse.json(result);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json(
+      { error: message },
+      { status: error instanceof ReadError ? error.status : 500 }
+    );
+  }
+}

package/app/api/search/conversations/context/route.ts

@@ -0,0 +1,26 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { getMessageContext } from "@/lib/search/conversations";
+
+const Query = z.object({
+  session: z.string().min(1).max(100),
+  item: z.string().min(1).max(200),
+  around: z.coerce.number().int().min(0).max(6).default(3),
+});
+
+// GET /api/search/conversations/context?session=&item=&around= - a message and
+// the ones around it, for the preview. Read-only.
+export async function GET(request: Request) {
+  const parsed = Query.safeParse(
+    Object.fromEntries(new URL(request.url).searchParams)
+  );
+  if (!parsed.success)
+    return NextResponse.json({ error: "Bad request" }, { status: 400 });
+  const { session, item, around } = parsed.data;
+  const items = getMessageContext(session, item, around);
+  if (!items) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  return NextResponse.json(
+    { items },
+    { headers: { "Cache-Control": "no-store" } }
+  );
+}

package/app/api/search/conversations/route.test.ts

@@ -0,0 +1,139 @@
+import { randomUUID } from "crypto";
+import { describe, expect, it } from "vitest";
+import { getDb } from "@/lib/db";
+import type { ChatItem } from "@/lib/chat/events";
+import { saveItem } from "@/lib/chat/store";
+import * as route from "./route";
+import * as contextRoute from "./context/route";
+
+const get = (qs: Record<string, string>) =>
+  route.GET(
+    new Request(
+      `http://localhost/api/search/conversations?${new URLSearchParams(qs)}`
+    )
+  );
+
+function setup() {
+  const db = getDb();
+  const tag = randomUUID().slice(0, 6);
+  const ws = (n: string) => {
+    const id = `ws-${tag}-${n}`;
+    db.prepare(`INSERT INTO workspaces (id, name) VALUES (?, ?)`).run(
+      id,
+      `Space ${n}`
+    );
+    return id;
+  };
+  const a = ws("a");
+  const b = ws("b");
+  const proj = (n: string, w: string) => {
+    const id = `p-${tag}-${n}`;
+    db.prepare(
+      `INSERT INTO projects (id, name, working_directory, workspace_id) VALUES (?, ?, '/tmp/x', ?)`
+    ).run(id, `Proj ${n}`, w);
+    return id;
+  };
+  const pa = proj("a", a);
+  const pb = proj("b", b);
+  const chat = (
+    name: string,
+    project: string | null,
+    ws: string | null,
+    text: string,
+    archived = false
+  ) => {
+    const sid = randomUUID();
+    db.prepare(
+      `INSERT INTO sessions (id, name, tmux_name, working_directory, project_id, workspace_id, archived_at)
+       VALUES (?, ?, ?, '/tmp', ?, ?, ?)`
+    ).run(
+      sid,
+      name,
+      `claude-${sid}`,
+      project,
+      ws,
+      archived ? "2026-01-01" : null
+    );
+    for (let i = 0; i < 5; i++)
+      saveItem(sid, {
+        id: `${sid}-${i}`,
+        kind: i % 2 ? "assistant" : "user",
+        text: `${text} ${i}`,
+        createdAt: 1,
+      } as ChatItem);
+    return sid;
+  };
+  return { a, b, pa, pb, chat, word: `lynx${tag}` };
+}
+
+describe("GET /api/search/conversations", () => {
+  it("scopes to a workspace, all of them, or a project", async () => {
+    const { a, b, pa, chat, word } = setup();
+    const inA = chat("in a", pa, null, word);
+    const direct = chat("direct", null, a, word);
+    chat("in b", `p-${word.slice(4)}-b`, null, word);
+    const only = async (qs: Record<string, string>) =>
+      (
+        (await (await get({ q: word, ...qs })).json()).groups as {
+          sessionId: string;
+        }[]
+      )
+        .map((g) => g.sessionId)
+        .sort();
+    expect(await only({ workspace: a })).toEqual([inA, direct].sort());
+    expect((await only({ workspace: "all" })).length).toBe(3);
+    expect(await only({ workspace: "all", project: pa })).toEqual([inA]);
+    expect(await only({ workspace: b })).toHaveLength(1);
+  });
+
+  it("includes archived conversations and labels them, with the match marked", async () => {
+    const { chat, word } = setup();
+    chat("old", null, null, `${word} cleanup`, true);
+    const body = await (await get({ q: word.slice(0, -1) })).json();
+    expect(body.groups).toHaveLength(1);
+    const g = body.groups[0];
+    expect(g.status).toBe("archived");
+    expect(g.hits.length).toBeLessThanOrEqual(3);
+    expect(g.hits[0].snippet.some((s: { hit: boolean }) => s.hit)).toBe(true);
+    expect(body.terms).toEqual([word.slice(0, -1)]);
+  });
+
+  it("rejects bad input and treats short queries as empty", async () => {
+    expect((await get({ q: "x", limit: "999" })).status).toBe(400);
+    expect((await get({ q: "x".repeat(300) })).status).toBe(400);
+    const r = await get({ q: "a" });
+    expect((await r.json()).groups).toEqual([]);
+  });
+
+  it("answers hostile query text with results, not an error", async () => {
+    const r = await get({ q: '"AND" OR NEAR( * ^ col: "' });
+    expect(r.status).toBe(200);
+  });
+
+  it("only reads", () => {
+    expect(Object.keys(route).sort()).toEqual(["GET"]);
+    expect(Object.keys(contextRoute).sort()).toEqual(["GET"]);
+  });
+
+  it("serves a message with its neighbours, and 404s a missing one", async () => {
+    const { chat, word } = setup();
+    const sid = chat("ctx", null, null, word);
+    const ok = await contextRoute.GET(
+      new Request(
+        `http://localhost/x?${new URLSearchParams({ session: sid, item: `${sid}-2`, around: "1" })}`
+      )
+    );
+    const items = (await ok.json()).items as { id: string; hit: boolean }[];
+    expect(items.map((i) => i.id)).toEqual([
+      `${sid}-1`,
+      `${sid}-2`,
+      `${sid}-3`,
+    ]);
+    const missing = await contextRoute.GET(
+      new Request(
+        `http://localhost/x?${new URLSearchParams({ session: sid, item: "nope" })}`
+      )
+    );
+    expect(missing.status).toBe(404);
+  });
+});

package/app/api/search/conversations/route.ts

@@ -0,0 +1,25 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { searchConversations } from "@/lib/search/conversations";
+
+const Query = z.object({
+  q: z.string().max(200).default(""),
+  workspace: z.string().min(1).max(100).default("all"),
+  project: z.string().min(1).max(100).optional(),
+  offset: z.coerce.number().int().min(0).max(200).default(0),
+  limit: z.coerce.number().int().min(1).max(30).default(20),
+});
+
+// GET /api/search/conversations?q=&workspace=<id|all>&project=&offset=&limit=
+// - what was said in chats, grouped by conversation. Read-only.
+export async function GET(request: Request) {
+  const params = Object.fromEntries(new URL(request.url).searchParams);
+  const parsed = Query.safeParse(params);
+  if (!parsed.success)
+    return NextResponse.json({ error: "Bad search" }, { status: 400 });
+  const { q, workspace, project, offset, limit } = parsed.data;
+  return NextResponse.json(
+    searchConversations(q, { workspace, project }, { offset, limit }),
+    { headers: { "Cache-Control": "no-store" } }
+  );
+}

package/app/globals.css

@@ -309,3 +309,28 @@ body {
   background-color: hsl(var(--find-current));
   color: hsl(var(--find-current-foreground));
 }
+
+/* A message just jumped to (components/Chat/useGoToItem). */
+@keyframes jump-flash {
+  from {
+    background-color: hsl(var(--primary) / 0.22);
+  }
+  to {
+    background-color: transparent;
+  }
+}
+[data-block][data-flash] {
+  animation: jump-flash 1.8s ease-out;
+  border-radius: 0.75rem;
+}
+@media (prefers-reduced-motion: reduce) {
+  [data-block][data-flash] {
+    animation: none;
+    background-color: hsl(var(--primary) / 0.12);
+  }
+}
+
+/* Matches in the search preview (components/CommandPalette/conversations). */
+::highlight(conv-search) {
+  background-color: hsl(var(--find-match));
+}

package/components/Bookmarks/BookmarksDialog.tsx

@@ -15,7 +15,7 @@ import { useBookmarks, type Bookmark } from "@/data/bookmarks";
 import { useWorkspacesQuery } from "@/data/workspaces";
 import { useUnarchiveSession } from "@/data/done";
 import { toast } from "sonner";
-import { hrefWithSession } from "@/lib/session-url";
+import { openChatAt } from "@/stores/chatJump";
 import { bookmarksUi, bookmarksUiActions } from "@/stores/bookmarksUi";
 import { BookmarkRow } from "./BookmarkRow";
 import { EmptyBookmarks } from "./EmptyBookmarks";
@@ -24,13 +24,7 @@ import { groupByDay } from "./helpers";
 // Opens the chat by its address, then takes it to the message.
 function openChat(b: Bookmark) {
   bookmarksUiActions.setOpen(false);
-  window.history.pushState(
-    null,
-    "",
-    hrefWithSession(location.href, b.sessionId)
-  );
-  window.dispatchEvent(new PopStateEvent("popstate"));
-  bookmarksUiActions.jump(b.sessionId, b.itemId);
+  openChatAt(b.sessionId, b.itemId);
 }
 
 // Every bookmark: one workspace's or all of them, searched on the server.

package/components/Chat/useGoToItem.ts

@@ -17,6 +17,16 @@ interface Deps {
   foldEvents: boolean;
 }
 
+// The message arrived at is marked for a moment (app/globals.css fades it).
+function flash(block: string) {
+  const el = document.querySelector(`[data-block="${CSS.escape(block)}"]`);
+  if (!el) return;
+  el.removeAttribute("data-flash");
+  void (el as HTMLElement).offsetWidth;
+  el.setAttribute("data-flash", "");
+  setTimeout(() => el.removeAttribute("data-flash"), 2000);
+}
+
 // Takes the reader to a message by a rule over the loaded items (the strip's
 // "the message where the question was asked"): older pages load until it is
 // found, then its folded rows open and it scrolls into view.
@@ -54,6 +64,7 @@ export function useGoToItem(d: Deps) {
           )
           ?.scrollIntoView({ block: "center" })
       )
+      .then(() => flash(where.block))
       .catch(() => {});
   }, [
     find,

package/components/CommandPalette/CommandPalette.tsx

@@ -1,182 +1,49 @@
 "use client";
 
-import { useEffect, useMemo, useRef, useState } from "react";
 import { useSnapshot } from "valtio";
-import { Search, type LucideIcon } from "lucide-react";
 import {
   Dialog,
   DialogContent,
   DialogDescription,
   DialogTitle,
 } from "@/components/ui/dialog";
-import { matchCommands, type PaletteCommand } from "@/lib/palette/registry";
 import { cn } from "@/lib/utils";
-import { usePaletteList } from "@/hooks/usePaletteCommands";
 import { paletteActions, paletteUi } from "@/stores/palette";
-
-// How many of a long group (sessions) show before a query narrows it.
-const GROUP_PREVIEW = 8;
+import { CommandsBody } from "./CommandsBody";
+import { ConversationSearch } from "./conversations/ConversationSearch";
 
 // ⌘K anywhere, or the header button on a phone: every action the open
-// features offer, found by typing.
+// features offer, found by typing, and (Tab) what was said in any chat.
 export function CommandPalette() {
-  const { open } = useSnapshot(paletteUi);
+  const { open, mode } = useSnapshot(paletteUi);
+  const wide = mode === "conversations";
   return (
     <Dialog open={open} onOpenChange={paletteActions.setOpen}>
       <DialogContent
         showCloseButton={false}
         // Sized to what the keyboard leaves visible (--app-height), not vh.
-        className="top-[max(env(safe-area-inset-top),1rem)] flex max-h-[min(calc(var(--app-height,100dvh)-env(safe-area-inset-top)-2rem),560px)] translate-y-0 flex-col gap-0 overflow-hidden p-0 sm:top-[15vh] sm:max-h-[min(calc(var(--app-height,100dvh)-15vh-1rem),560px)] sm:max-w-lg"
+        className={cn(
+          "top-[max(env(safe-area-inset-top),1rem)] flex translate-y-0 flex-col gap-0 overflow-hidden p-0 sm:top-[15vh]",
+          wide
+            ? "h-[calc(var(--app-height,100dvh)-env(safe-area-inset-top)-2rem)] sm:h-[min(calc(var(--app-height,100dvh)-15vh-1rem),600px)] sm:max-w-4xl"
+            : "max-h-[min(calc(var(--app-height,100dvh)-env(safe-area-inset-top)-2rem),560px)] sm:max-h-[min(calc(var(--app-height,100dvh)-15vh-1rem),560px)] sm:max-w-lg"
+        )}
       >
-        <DialogTitle className="sr-only">Command palette</DialogTitle>
+        <DialogTitle className="sr-only">
+          {wide ? "Search conversations" : "Command palette"}
+        </DialogTitle>
         <DialogDescription className="sr-only">
-          Search for an action or a session
+          {wide
+            ? "Search what was said in every conversation"
+            : "Search for an action, a session or a conversation"}
         </DialogDescription>
-        {/* Mounted per opening, so each starts with an empty query. */}
-        <PaletteBody />
+        {/* Mounted per opening and per mode, so each starts from its own query. */}
+        {wide ? (
+          <ConversationSearch key="conversations" />
+        ) : (
+          <CommandsBody key="commands" />
+        )}
       </DialogContent>
     </Dialog>
   );
 }
-
-function PaletteBody() {
-  const commands = usePaletteList();
-  // Subscribed for changes, read raw: its items are held by ref.
-  useSnapshot(paletteUi);
-  const picker = paletteUi.picker;
-  const all = picker?.items ?? commands;
-  const [query, setQuery] = useState("");
-  const [active, setActive] = useState(0);
-  const listRef = useRef<HTMLDivElement>(null);
-
-  const results = useMemo(() => {
-    if (query.trim()) return matchCommands(all, query);
-    // A picker shows every choice; it's the whole list.
-    if (picker) return all;
-    // With no query, long groups are cut short so every group shows.
-    const seen = new Map<string, number>();
-    return all.filter((c) => {
-      const n = (seen.get(c.group) ?? 0) + 1;
-      seen.set(c.group, n);
-      return n <= GROUP_PREVIEW;
-    });
-  }, [all, query, picker]);
-  const highlighted = Math.min(active, Math.max(results.length - 1, 0));
-
-  useEffect(() => {
-    listRef.current
-      ?.querySelector(`[data-index="${highlighted}"]`)
-      ?.scrollIntoView({ block: "nearest" });
-  }, [highlighted]);
-
-  const run = (c: PaletteCommand | undefined) => {
-    if (!c) return;
-    paletteActions.setOpen(false);
-    // After the dialog lets go of focus, so what it opens can take it.
-    setTimeout(() => c.run(), 0);
-  };
-
-  // Under their headings with no query; one ranked list with one.
-  const groups: { name: string; items: { c: PaletteCommand; i: number }[] }[] =
-    [];
-  results.forEach((c, i) => {
-    const name = query.trim() ? "" : c.group;
-    let g = groups.find((x) => x.name === name);
-    if (!g) groups.push((g = { name, items: [] }));
-    g.items.push({ c, i });
-  });
-
-  return (
-    <>
-      <div className="border-foreground/[0.06] flex items-center gap-2 border-b px-3">
-        <Search className="text-muted-foreground h-4 w-4 shrink-0" />
-        <input
-          autoFocus
-          value={query}
-          onChange={(e) => {
-            setQuery(e.target.value);
-            setActive(0);
-          }}
-          onKeyDown={(e) => {
-            if (e.key === "ArrowDown" || e.key === "ArrowUp") {
-              e.preventDefault();
-              const n = results.length || 1;
-              setActive(
-                (highlighted + (e.key === "ArrowDown" ? 1 : -1) + n) % n
-              );
-            } else if (e.key === "Enter") {
-              e.preventDefault();
-              run(results[highlighted]);
-            } else if (
-              picker &&
-              (e.metaKey || e.ctrlKey) &&
-              /^[1-9]$/.test(e.key)
-            ) {
-              e.preventDefault();
-              run(picker.items[Number(e.key) - 1]);
-            }
-          }}
-          placeholder={picker?.placeholder ?? "Search actions and sessions…"}
-          aria-label={picker?.placeholder ?? "Search actions and sessions"}
-          className="placeholder:text-muted-foreground h-12 min-w-0 flex-1 bg-transparent text-base outline-none sm:text-sm"
-        />
-        <kbd className="text-muted-foreground hidden font-mono text-[10px] sm:inline">
-          esc
-        </kbd>
-      </div>
-      <div
-        ref={listRef}
-        role="listbox"
-        className="min-h-0 flex-1 overflow-y-auto overscroll-contain p-1.5"
-      >
-        {results.length === 0 && (
-          <p className="text-muted-foreground py-8 text-center text-sm">
-            Nothing matches.
-          </p>
-        )}
-        {groups.map((g) => (
-          <div key={g.name || "results"} className="mb-1">
-            {g.name && (
-              <p className="text-muted-foreground px-2 pt-2 pb-1 text-[11px] font-medium">
-                {g.name}
-              </p>
-            )}
-            {g.items.map(({ c, i }) => {
-              const Icon = c.icon as LucideIcon | undefined;
-              return (
-                <button
-                  key={c.id}
-                  type="button"
-                  role="option"
-                  aria-selected={i === highlighted}
-                  data-index={i}
-                  onMouseMove={() => i !== highlighted && setActive(i)}
-                  onClick={() => run(c)}
-                  className={cn(
-                    "flex min-h-11 w-full items-center gap-2.5 rounded-lg px-2 text-left text-sm md:min-h-9",
-                    i === highlighted && "bg-primary/10"
-                  )}
-                >
-                  {Icon && (
-                    <Icon className="text-muted-foreground h-4 w-4 shrink-0" />
-                  )}
-                  <span className="min-w-0 flex-1 truncate">{c.title}</span>
-                  {query.trim() && (
-                    <span className="text-muted-foreground shrink-0 text-xs">
-                      {c.group}
-                    </span>
-                  )}
-                  {c.hint && (
-                    <kbd className="text-muted-foreground hidden shrink-0 font-mono text-[11px] sm:inline">
-                      {c.hint}
-                    </kbd>
-                  )}
-                </button>
-              );
-            })}
-          </div>
-        ))}
-      </div>
-    </>
-  );
-}