@saadnvd1/agent-os 0.3.489 → 0.3.494

package/README.md

@@ -920,7 +920,13 @@ other sessions. Sessions sit on shelves: **Pinned** (pin from a row's ⋯
 menu), **Needs you** (an approval, a question, a terminal waiting for input, a
 message typed and never sent, a failed task, or the orchestrator's open asks,
 each with a badge), **Working**,
-and **Done**, newest first, ten at a time. A purple dot marks a session that
+and **Done**. Done is folded to one row, "3 done today · 12 earlier", until you
+tap it (open or folded is remembered per device); open, it lists newest first,
+ten at a time. The orchestrator's row carries small chips for the work it
+started: running, in review, blocked and queued, each left out at zero. Tap
+them to show only that orchestrator's work on the same shelves; the "Showing
+… work ×" chip at the top clears it (it resets on reload). A session an
+orchestrator started has a small orchestrator icon on its row. A purple dot marks a session that
 finished or changed since you last opened it. Search matches
 titles and project names, and the project filter narrows the list to one
 project and holds that project's own actions: new session, terminal, dev
@@ -1059,7 +1065,31 @@ it may do on its own, and the lines that always come back to you as asks.
   arrives marked as from that orchestrator and fenced as untrusted, so it can't
   approve, answer an ask or pass a gate. The route
   they call answers only the orchestrator's worker, by a per-orchestrator
-  secret. Its shell runs only `aos` commands that read.
+  secret.
+- **Shell:** it runs anything without asking, so an orchestrator can read and
+  investigate on its own: `gh pr list`, `gh run view --log-failed`, `gh api`
+  GETs, `curl`, `sqlite3 -readonly`, git in any repository, a skill's scripts,
+  pipes and chains. Its chat worker refuses a deny list before a command runs,
+  naming the tool to use instead: merging, closing or retargeting a PR
+  (`gh pr merge`, `gh pr close`, `gh pr edit --base`, and `gh api` or `curl`
+  calls that merge a pull request or PATCH or PUT one; use `sign_off`, `arm`,
+  `land` or `drop`), `git push` (`quick_pr` pushes), writing in a project
+  repository or task worktree other than its own open quick changes (git
+  commit, reset, checkout, rebase, merge, stash, clean or rm there, and `rm`,
+  `mv`, `cp`, `tee` or a redirect into one), writing AgentOS's state (`sqlite3`
+  on its database without `-readonly` or with INSERT, UPDATE, DELETE, DROP,
+  ALTER or ATTACH; files under `~/.agent-os` outside its folder), stopping
+  AgentOS or its tmux (`pkill`/`kill` aimed at it, `tmux kill-*`, a
+  `launchctl` or `serviceman` restart), and reading secret files (the same
+  list as the write guard) or tokenvault (`tv get`, `tv dump`). It reads each
+  command line the way a shell would, so these are caught inside pipes,
+  chains and `$( )`, behind `bash -c`, `sh -c`, `env`, `sudo`, `xargs`,
+  `find -exec` or an absolute path, and after a `cd` or `git -C`. **The deny
+  list catches honest mistakes, not a determined bypass:** a script or
+  `python -c` can do any of these where no parser sees it, and an
+  orchestrator reads other sessions' text, which can carry planted
+  instructions. The trade-off was chosen on 2026-10-11, for an orchestrator
+  that does its own investigating instead of handing it to him.
 - **Triage:** its brief has it decide each job: small and clear is a task with
   `plan: false` and the steps written into the brief; big, unclear or
   cross-cutting is `plan: true`; work outside a repository is a
@@ -1191,6 +1221,12 @@ it may do on its own, and the lines that always come back to you as asks.
   Nothing is lost, because its state lives in the database; its chat goes on,
   with a line where it started over. The same can be switched on for chat
   tasks (off by default: a task keeps only its brief and its branch).
+  **Start fresh by hand:** after a deploy that changes its permissions or
+  brief, use **New conversation (keep brief)** in the orchestrator's row menu or type `/fresh`
+  in its chat (task chats have both too). It takes the threshold's path: an
+  idle agent starts over at once; a running turn finishes first, with a
+  "Starts fresh after this turn" line. The next conversation launches with
+  the brief, permissions and workspace state the server has then.
 - **Events:** the server sends it one short line per event (a PR opened, CI
   failed, or green once it has settled so `sign_off`'s ci gate passes, a `BLOCKED:` line, a merge, a session needing input, a
   stack step, a task idle 30 minutes with no PR, a review's verdict). Events

package/app/api/sessions/[id]/fresh/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from "next/server";
+import { queries, db, type Session } from "@/lib/db";
+import { FreshRefusal, freshStartChat } from "@/lib/chat/runner";
+
+// POST /api/sessions/:id/fresh - start the agent's conversation over (the
+// path the context threshold takes, lib/chat/refresh): now if it's idle,
+// else at the next turn boundary. Only for chats whose state lives outside
+// the conversation: an orchestrator, or a task with a brief.
+export async function POST(
+  _request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const session = queries.getSession(db).get(id) as Session | undefined;
+  if (!session)
+    return NextResponse.json({ error: "Session not found" }, { status: 404 });
+  if (session.role !== "orchestrator" && !session.task_brief)
+    return NextResponse.json(
+      { error: "Only an orchestrator or a task can start fresh" },
+      { status: 400 }
+    );
+  try {
+    return NextResponse.json({ when: await freshStartChat(id) });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json(
+      { error: message },
+      { status: error instanceof FreshRefusal ? 409 : 500 }
+    );
+  }
+}

package/components/Chat/ChatPanel.tsx

@@ -19,6 +19,8 @@ import {
   type TimelineBlock,
 } from "@/lib/chat/group";
 import type { ApprovalDecision, ChatItem } from "@/lib/chat/events";
+import { isFreshCommand, withFresh } from "@/lib/chat/commands";
+import { useFreshStart } from "@/data/sessions";
 import {
   escapeAction,
   GHOST_SELECTOR,
@@ -206,6 +208,7 @@ export function ChatPanel({
   sessionName,
   accessLocked = false,
   orchestratorOf,
+  freshStart = false,
   active,
 }: {
   sessionId: string;
@@ -214,6 +217,8 @@ export function ChatPanel({
   accessLocked?: boolean;
   // The workspace it orchestrates: its header line, Pause and asks show on top.
   orchestratorOf?: string | null;
+  // An orchestrator or task: /fresh starts its conversation over.
+  freshStart?: boolean;
   // The tab on show in the focused pane: opening it takes the caret.
   active: boolean;
 }) {
@@ -226,6 +231,7 @@ export function ChatPanel({
     earlierTasks,
     toolBodies,
     requestToolBody,
+    pinToolBody,
     state,
     connected,
     commands,
@@ -258,6 +264,7 @@ export function ChatPanel({
     requestFiles,
     search,
   } = useChat(sessionId, (text) => setPrefill({ text, at: Date.now() }));
+  const startFresh = useFreshStart();
   const { isMobile } = useViewport();
   const scrollRef = useRef<HTMLDivElement>(null);
   const listRef = useRef<HTMLDivElement>(null);
@@ -364,8 +371,13 @@ export function ChatPanel({
   // eslint-disable-next-line react-hooks/exhaustive-deps
   const rowState = useMemo(() => new RowStore(), [sessionId]);
   const bodies = useMemo(
-    () => ({ bodies: toolBodies, request: requestToolBody, connected }),
-    [toolBodies, requestToolBody, connected]
+    () => ({
+      bodies: toolBodies,
+      request: requestToolBody,
+      pin: pinToolBody,
+      connected,
+    }),
+    [toolBodies, requestToolBody, pinToolBody, connected]
   );
   const itemsById = useMemo(
     () => new Map(items.map((i) => [i.id, i])),
@@ -574,6 +586,10 @@ export function ChatPanel({
           disabled={!connected}
           placeholder={connected ? `Message ${sessionName}` : "Reconnecting…"}
           onSend={(text, images) => {
+            if (freshStart && isFreshCommand(text)) {
+              startFresh.mutate(sessionId);
+              return;
+            }
             toEnd();
             const compact = composerCompacts(text, context, {
               state,
@@ -584,7 +600,7 @@ export function ChatPanel({
             send(text, images.length ? images : undefined, compact);
           }}
           onStop={interrupt}
-          commands={commands}
+          commands={freshStart ? withFresh(commands) : commands}
           onRefreshCommands={refreshCommands}
           refreshingCommands={refreshingCommands}
           models={models}

package/components/Chat/Tools.tsx

@@ -5,6 +5,7 @@ import { Check, ChevronRight, Loader2, Square, X } from "lucide-react";
 import type { FileDiff, ToolBody } from "@/lib/chat/events";
 import type { ToolItem } from "@/lib/chat/group";
 import { lineDiff, shortPath, type DiffLine } from "@/lib/chat/diff";
+import { needsBody } from "@/lib/chat/bodyCache";
 import { cn } from "@/lib/utils";
 import { formatElapsed } from "@/lib/chat/elapsed";
 import { Highlighted } from "./Code";
@@ -16,16 +17,21 @@ import { useRowState } from "./rowState";
 export const ToolBodies = createContext<{
   bodies: Record<string, ToolBody | null>;
   request: (id: string) => void;
+  // Marks a body as on screen until the returned cleanup runs.
+  pin: (id: string) => () => void;
   connected: boolean;
-}>({ bodies: {}, request: () => {}, connected: false });
+}>({ bodies: {}, request: () => {}, pin: () => () => {}, connected: false });
 
 // A tool call's output and diff: its own, or once loaded. `undefined` while
 // it loads.
 export function useToolBody(tool: ToolItem): ToolBody | null | undefined {
-  const { bodies, request, connected } = useContext(ToolBodies);
+  const { bodies, request, pin, connected } = useContext(ToolBodies);
   const body = tool.deferred ? bodies[tool.id] : tool;
   useEffect(() => {
-    if (tool.deferred && body === undefined && connected) request(tool.id);
+    if (tool.deferred) return pin(tool.id);
+  }, [tool.deferred, tool.id, pin]);
+  useEffect(() => {
+    if (needsBody(tool.deferred, body, connected)) request(tool.id);
   }, [tool.deferred, tool.id, body, request, connected]);
   return body;
 }

package/components/Pane/index.tsx

@@ -289,6 +289,10 @@ export const Pane = memo(function Pane({
           sessionId={chat.id}
           sessionName={chat.name}
           accessLocked={chat.role === "orchestrator"}
+          freshStart={
+            (chat.role === "orchestrator" || !!chat.task_brief) &&
+            !chat.archived_at
+          }
           orchestratorOf={
             chat.role === "orchestrator" ? chat.workspace_id : null
           }

package/components/SessionList/OrchestratorPinRow.test.ts

@@ -77,6 +77,8 @@ describe("OrchestratorPinRow", () => {
     orchestrators: [],
     runningByWorkspace: new Map(),
     queuedByWorkspace: new Map(),
+    rollups: new Map(),
+    orchestratorNames: new Map(),
     orderedIds: () => [],
     cardUrl: () => null,
     onSelect,
@@ -86,6 +88,7 @@ describe("OrchestratorPinRow", () => {
     onDelete: vi.fn(),
     onMoveToProject: vi.fn(),
     onPin: vi.fn(),
+    onFresh: vi.fn(),
   };
   const render = (over: Partial<RowContextValue> = {}, unread = false) =>
     act(async () =>

package/components/SessionList/OrchestratorPinRow.tsx

@@ -6,6 +6,9 @@ import { Button } from "@/components/ui/button";
 import * as DM from "@/components/ui/dropdown-menu";
 import * as CM from "@/components/ui/context-menu";
 import { sameRow, type SidebarRow } from "@/lib/sidebar/shelves";
+import { visibleChips } from "@/lib/sidebar/rollup";
+import { sidebarUi, sidebarUiActions } from "@/stores/sidebarUi";
+import { useSnapshot } from "valtio";
 import { orchestratorRowText } from "@/lib/sidebar/orchestrator-row";
 import { cn } from "@/lib/utils";
 import { orchestratorOpenActions } from "@/stores/orchestratorOpen";
@@ -36,6 +39,9 @@ export const OrchestratorPinRow = memo(function OrchestratorPinRow({
     inReview: overview?.inReview ?? 0,
     queued: ctx.queuedByWorkspace.get(ws) ?? 0,
   });
+  const chips = visibleChips(ctx.rollups.get(session.id));
+  const { orchestratorId } = useSnapshot(sidebarUi);
+  const filtering = orchestratorId === session.id;
   const label = ctx.workspaceNames.get(ws) ?? "Orchestrator";
   const summary = asks ? `${status} · ${asks}` : status;
   const menu = (kind: "dropdown" | "context") => (
@@ -100,6 +106,36 @@ export const OrchestratorPinRow = memo(function OrchestratorPinRow({
                 </>
               )}
             </span>
+            {chips.length > 0 && (
+              <button
+                type="button"
+                aria-pressed={filtering}
+                title={`Show only ${label}'s work`}
+                onClick={(e) => {
+                  e.stopPropagation();
+                  sidebarUiActions.setOrchestrator(
+                    filtering ? null : session.id
+                  );
+                }}
+                className={cn(
+                  "text-muted-foreground -mx-1 mt-0.5 flex min-h-6 flex-wrap items-center gap-x-2.5 rounded px-1 text-xs",
+                  "hover:bg-muted hover:text-foreground md:min-h-5",
+                  filtering && "bg-muted text-foreground"
+                )}
+              >
+                {chips.map((c) => (
+                  <span key={c.key} className="flex items-center gap-1">
+                    <span
+                      aria-hidden
+                      className={cn("h-1.5 w-1.5 rounded-full", c.dot)}
+                    />
+                    <span className="tabular-nums">
+                      {ctx.rollups.get(session.id)![c.key]} {c.label}
+                    </span>
+                  </span>
+                ))}
+              </button>
+            )}
           </>
         )}
       </span>

package/components/SessionList/RowContext.tsx

@@ -2,6 +2,7 @@
 
 import { createContext, useContext } from "react";
 import type { ProjectWithRepositories } from "@/lib/projects";
+import type { Rollup } from "@/lib/sidebar/rollup";
 import type { OrchestratorOverview } from "@/lib/orchestrator/overview";
 
 // What every row needs from the list, so shelves don't pass it along.
@@ -14,6 +15,9 @@ export interface RowContextValue {
   orchestrators: OrchestratorOverview[];
   runningByWorkspace: Map<string, number>;
   queuedByWorkspace: Map<string, number>;
+  // What each orchestrator session started, and its name (its workspace's).
+  rollups: Map<string, Rollup>;
+  orchestratorNames: Map<string, string>;
   // Render order, for shift-click range selection.
   orderedIds: () => string[];
   cardUrl: (sessionId: string) => string | null | undefined;
@@ -25,6 +29,7 @@ export interface RowContextValue {
   onDelete: (sessionId: string) => void;
   onMoveToProject: (sessionId: string, projectId: string) => void;
   onPin: (sessionId: string, pinned: boolean) => void;
+  onFresh: (sessionId: string) => void;
 }
 
 const RowContext = createContext<RowContextValue | null>(null);

package/components/SessionList/SessionRow.tsx

@@ -2,7 +2,7 @@
 
 import { memo, useState } from "react";
 import { useSnapshot } from "valtio";
-import { CheckSquare, GitFork, Square } from "lucide-react";
+import { CheckSquare, GitFork, Square, Workflow } from "lucide-react";
 import { compactTimeAgo, fromSqliteTime } from "@/lib/session-meta";
 import { sameRow, type SidebarRow } from "@/lib/sidebar/shelves";
 import { useMinuteTick } from "@/hooks/useMinuteTick";
@@ -33,6 +33,9 @@ export const SessionRow = memo(function SessionRow({
   const [renaming, setRenaming] = useState(false);
   const { session } = row;
   const active = session.id === ctx.activeSessionId;
+  const viaName = session.started_by
+    ? ctx.orchestratorNames.get(session.started_by)
+    : undefined;
   const selecting = selectedIds.size > 0;
   const selected = selectedIds.has(session.id);
   const onClick = (e: React.MouseEvent) => {
@@ -76,9 +79,19 @@ export const SessionRow = memo(function SessionRow({
           )
         }
         aside={
-          session.parent_session_id && (
-            <GitFork className="text-muted-foreground/60 h-3 w-3 shrink-0" />
-          )
+          <>
+            {viaName && (
+              <span title={`Started by ${viaName}`} className="shrink-0">
+                <Workflow
+                  aria-label={`Via orchestrator: ${viaName}`}
+                  className="text-muted-foreground/60 h-3 w-3"
+                />
+              </span>
+            )}
+            {session.parent_session_id && (
+              <GitFork className="text-muted-foreground/60 h-3 w-3 shrink-0" />
+            )}
+          </>
         }
         trailing={
           <>

package/components/SessionList/SessionRowMenu.tsx

@@ -15,6 +15,7 @@ import {
   Pencil,
   Pin,
   PinOff,
+  RotateCcw,
   Sparkles,
   Trash2,
 } from "lucide-react";
@@ -174,6 +175,15 @@ export function SessionRowMenu({
           {summarizing ? "Summarizing..." : "Fresh start"}
         </Item>
       )}
+      {(session.role === "orchestrator" || session.task_brief) &&
+        session.view === "chat" &&
+        !session.archived_at &&
+        !blocked && (
+          <Item onClick={() => ctx.onFresh(session.id)}>
+            <RotateCcw className={icon} />
+            New conversation (keep brief)
+          </Item>
+        )}
       {session.pr_url && (
         <Item onClick={() => window.open(session.pr_url!, "_blank")}>
           <GitPullRequest className={icon} />

package/components/SessionList/SessionShelves.tsx

@@ -2,7 +2,12 @@
 
 import type { ReactNode } from "react";
 import { ChevronDown } from "lucide-react";
-import { DONE_PAGE, doneLimit, type Shelves } from "@/lib/sidebar/shelves";
+import {
+  DONE_PAGE,
+  doneLimit,
+  doneSummary,
+  type Shelves,
+} from "@/lib/sidebar/shelves";
 import type { MachineGroup } from "@/lib/sidebar/machines";
 import { sidebarUiActions } from "@/stores/sidebarUi";
 import { cn } from "@/lib/utils";
@@ -97,6 +102,7 @@ export function SessionShelves({
 }) {
   const shown = shelves.done.slice(0, doneLimit(donePages));
   const hidden = shelves.done.length - shown.length;
+  const summary = doneSummary(shelves.done).text;
   return (
     <>
       {shelves.orchestrators.length + toStart.length > 0 && (
@@ -140,7 +146,7 @@ export function SessionShelves({
       {shelves.done.length > 0 && (
         <section aria-label="Done">
           <ShelfLabel
-            label="Done"
+            label={doneCollapsed ? summary : "Done"}
             collapsed={doneCollapsed}
             onToggle={sidebarUiActions.toggleDone}
           />

package/components/SessionList/SidebarBody.tsx

@@ -1,8 +1,9 @@
 "use client";
 
-import { AlertCircle, FolderPlus, Plus } from "lucide-react";
+import { AlertCircle, FolderPlus, Plus, X } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { ShimmeringLoader } from "@/components/ui/skeleton";
+import { sidebarUiActions } from "@/stores/sidebarUi";
 import type { SidebarData } from "./useSidebarData";
 import { MachineShelves, SessionShelves } from "./SessionShelves";
 import { SidebarExtras } from "./SidebarExtras";
@@ -71,6 +72,21 @@ export function SidebarBody({
 
   return (
     <>
+      {ui.orchestratorId && (
+        <button
+          type="button"
+          onClick={() => sidebarUiActions.setOrchestrator(null)}
+          aria-label="Clear the orchestrator filter"
+          className="bg-muted hover:bg-muted/70 text-foreground mx-2.5 mt-2 flex min-h-8 max-w-[calc(100%-1.25rem)] items-center gap-1.5 rounded-full px-3 text-xs md:min-h-7"
+        >
+          <span className="truncate">
+            Showing{" "}
+            {data.orchestratorNames.get(ui.orchestratorId) ?? "orchestrator"}
+            &rsquo;s work
+          </span>
+          <X className="h-3 w-3 shrink-0" />
+        </button>
+      )}
       <DraftShelf projects={data.projects} />
       {count === 0 &&
         (ui.query ? (

package/components/SessionList/index.tsx

@@ -4,7 +4,7 @@ import { useLayoutEffect, useMemo, useRef, useState } from "react";
 import { Loader2 } from "lucide-react";
 import { ScrollArea } from "@/components/ui/scroll-area";
 import { useDocsWorkspace } from "@/data/lumifyhub/docs";
-import { usePinSession } from "@/data/sessions";
+import { useFreshStart, usePinSession } from "@/data/sessions";
 import { useOrchestratorsQuery } from "@/data/orchestrators";
 import { docsUiActions } from "@/stores/docsUi";
 import type { SidebarRow } from "@/lib/sidebar/shelves";
@@ -47,6 +47,7 @@ export function SessionList({
   const mutations = useSessionListMutations({ onSelectSession: onSelect });
   const bulkDelete = useBulkDelete();
   const pin = usePinSession();
+  const fresh = useFreshStart();
   const { data: orchestrators = NO_ORCHESTRATORS } = useOrchestratorsQuery();
   const [dialog, setDialog] = useState<SidebarDialog | null>(null);
   const addProject = useAddProject();
@@ -70,9 +71,23 @@ export function SessionList({
   // Rows read their handlers through the latest render, so the context only
   // changes when what rows draw does: a status push redraws the rows it
   // touched, not the whole list.
-  const latest = useRef({ orderedIds, onSelect, onOpenInTab, mutations, pin });
+  const latest = useRef({
+    orderedIds,
+    onSelect,
+    onOpenInTab,
+    mutations,
+    pin,
+    fresh,
+  });
   useLayoutEffect(() => {
-    latest.current = { orderedIds, onSelect, onOpenInTab, mutations, pin };
+    latest.current = {
+      orderedIds,
+      onSelect,
+      onOpenInTab,
+      mutations,
+      pin,
+      fresh,
+    };
   });
   const canOpenInTab = !!onOpenInTab;
   const handlers = useMemo(
@@ -92,6 +107,7 @@ export function SessionList({
         latest.current.mutations.handleMoveSessionToProject(id, projectId),
       onPin: (id: string, pinned: boolean) =>
         latest.current.pin.mutate({ id, pinned }),
+      onFresh: (id: string) => latest.current.fresh.mutate(id),
     }),
     [canOpenInTab]
   );
@@ -110,6 +126,8 @@ export function SessionList({
       orchestrators,
       runningByWorkspace: data.runningByWorkspace,
       queuedByWorkspace: data.queuedByWorkspace,
+      rollups: data.rollupByOrchestrator,
+      orchestratorNames: data.orchestratorNames,
       cardUrl: data.taskCardUrl,
     }),
     [
@@ -122,6 +140,8 @@ export function SessionList({
       orchestrators,
       data.runningByWorkspace,
       data.queuedByWorkspace,
+      data.rollupByOrchestrator,
+      data.orchestratorNames,
       data.taskCardUrl,
     ]
   );

package/components/SessionList/useSidebarData.ts

@@ -15,6 +15,7 @@ import { useSessionsQuery } from "@/data/sessions";
 import { useLinkedHostNames } from "@/data/hosts";
 import { useProjectsQuery } from "@/data/projects";
 import { useQueuedTasksQuery, useTasksQuery } from "@/data/tasks";
+import { rollups, type Rollup } from "@/lib/sidebar/rollup";
 import { queuedRows } from "@/lib/sidebar/queued";
 import { useSelectedWorkspace } from "@/hooks/useSelectedWorkspace";
 import { useOrchestratorsQuery } from "@/data/orchestrators";
@@ -69,7 +70,7 @@ export function useSidebarData(
   );
   const project = workspaceProjects.find((p) => p.id === ui.projectId) ?? null;
 
-  const { shelves, machines } = useMemo(() => {
+  const { all, shelves, machines } = useMemo(() => {
     const byId = new Map(projects.map((p) => [p.id, p]));
     const workspaceName = new Map(workspaces.map((w) => [w.id, w.name]));
     const taskStates: Record<string, TaskState> = {};
@@ -84,23 +85,32 @@ export function useSidebarData(
       projectName,
       query: ui.query,
     };
+    const input = {
+      ...common,
+      sessions: sessions.filter(
+        (s) =>
+          !onMachineOnly(s, linked) &&
+          inWorkspace(
+            s,
+            (id) => byId.get(id)?.workspace_id,
+            workspace?.id ?? null
+          )
+      ),
+      projectId: project?.id ?? null,
+      currentOrchestrators,
+    };
+    // The rollups count the whole list; the filter only narrows what shows.
+    const all = buildShelves(input);
     return {
-      shelves: buildShelves({
-        ...common,
-        sessions: sessions.filter(
-          (s) =>
-            !onMachineOnly(s, linked) &&
-            inWorkspace(
-              s,
-              (id) => byId.get(id)?.workspace_id,
-              workspace?.id ?? null
-            )
-        ),
-        projectId: project?.id ?? null,
-        currentOrchestrators,
-      }),
-      // Not in any project, so not under a chosen one.
-      machines: project ? [] : machineGroups({ ...common, sessions }, linked),
+      all,
+      shelves: ui.orchestratorId
+        ? buildShelves({ ...input, startedBy: ui.orchestratorId })
+        : all,
+      // Not in any project, nor started by an orchestrator.
+      machines:
+        project || ui.orchestratorId
+          ? []
+          : machineGroups({ ...common, sessions }, linked),
     };
   }, [
     linked,
@@ -113,6 +123,7 @@ export function useSidebarData(
     workspace,
     project,
     ui.query,
+    ui.orchestratorId,
   ]);
 
   // Per workspace, how many of its project sessions are working: the
@@ -150,7 +161,7 @@ export function useSidebarData(
   );
 
   // Tasks waiting to start, in their line's order.
-  const queued = useMemo(
+  const queuedAll = useMemo(
     () =>
       queuedRows({
         queue,
@@ -161,6 +172,39 @@ export function useSidebarData(
       }),
     [queue, sessions, workspace, project, ui.query]
   );
+  const queued = useMemo(
+    () =>
+      ui.orchestratorId
+        ? queuedAll.filter((r) => r.item.startedBy === ui.orchestratorId)
+        : queuedAll,
+    [queuedAll, ui.orchestratorId]
+  );
+
+  // Each orchestrator's started work, keyed by its counts like the ones
+  // above so a push that changed none of them redraws no row.
+  const rollupKey = useMemo(
+    () => JSON.stringify([...rollups(all, queuedAll)].sort()),
+    [all, queuedAll]
+  );
+  const rollupByOrchestrator = useMemo(
+    () => new Map(JSON.parse(rollupKey) as [string, Rollup][]),
+    [rollupKey]
+  );
+
+  // Orchestrator session id -> the workspace it serves, for tags and chips.
+  const orchestratorKey = JSON.stringify(
+    sessions
+      .filter((s) => s.role === "orchestrator")
+      .map((s) => [
+        s.id,
+        workspaces.find((w) => w.id === s.workspace_id)?.name ?? s.name,
+      ])
+      .sort()
+  );
+  const orchestratorNames = useMemo(
+    () => new Map(JSON.parse(orchestratorKey) as [string, string][]),
+    [orchestratorKey]
+  );
 
   const taskCardUrl = useCallback(
     (id: string) => tasks.find((t) => t.id === id)?.cardUrl,
@@ -194,6 +238,8 @@ export function useSidebarData(
     projectNames,
     runningByWorkspace,
     queuedByWorkspace,
+    rollupByOrchestrator,
+    orchestratorNames,
     workspaces,
     workspace,
     workspaceProjects,