@saadnvd1/agent-os 0.3.853 → 0.3.859

package/app/api/leads/adopt/route.ts

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from "next/server";
+import { experimentOn } from "@/lib/experiments";
+import { requireApprover } from "@/lib/security/approver";
+import { getWorkspace } from "@/lib/workspaces";
+import { adoptLead } from "@/lib/leads/adopt";
+
+// Adopt an existing chat as one of a workspace's leads. It keeps its id,
+// its chat and its conversation; see lib/leads/adopt.
+export async function POST(request: NextRequest) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  if (!experimentOn("leads"))
+    return NextResponse.json(
+      { error: "Leads is off (Settings → Experiments)" },
+      { status: 409 }
+    );
+  const body = await request.json().catch(() => ({}));
+  const { sessionId, workspaceId, kind } = body as Record<string, unknown>;
+  if (typeof sessionId !== "string" || typeof kind !== "string")
+    return NextResponse.json(
+      { error: "Give sessionId, workspaceId and kind" },
+      { status: 400 }
+    );
+  if (typeof workspaceId !== "string" || !getWorkspace(workspaceId))
+    return NextResponse.json({ error: "Unknown workspace" }, { status: 404 });
+  try {
+    const session = await adoptLead({ sessionId, workspaceId, kind });
+    return NextResponse.json({ session });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 400 }
+    );
+  }
+}

package/app/api/leads/proposals/route.ts

@@ -0,0 +1,52 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import { getWorkspace } from "@/lib/workspaces";
+import { isLeadKind } from "@/lib/leads/roles";
+import { openProposals } from "@/lib/leads/direction";
+import { confirmPins } from "@/lib/leads/adopt";
+
+const bad = (error: string, status = 400) =>
+  NextResponse.json({ error }, { status });
+
+// A lead's pins waiting for the owner.
+export async function GET(request: NextRequest) {
+  const q = request.nextUrl.searchParams;
+  const workspaceId = q.get("workspaceId") ?? "";
+  const kind = q.get("kind") ?? "";
+  if (!getWorkspace(workspaceId)) return bad("Unknown workspace", 404);
+  if (!isLeadKind(kind)) return bad("Unknown lead");
+  return NextResponse.json({ proposals: openProposals(workspaceId, kind) });
+}
+
+// The owner's one tap: the confirmed proposals become pinned direction, the
+// rest are dropped, and with switchOver the lead starts fresh on its memo
+// and direction (an adopted lead's switch).
+export async function POST(request: NextRequest) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  const body = (await request.json().catch(() => ({}))) as Record<
+    string,
+    unknown
+  >;
+  const { workspaceId, kind, confirm, switchOver } = body;
+  if (typeof workspaceId !== "string" || !getWorkspace(workspaceId))
+    return bad("Unknown workspace", 404);
+  if (!isLeadKind(kind)) return bad("Unknown lead");
+  if (
+    !Array.isArray(confirm) ||
+    !confirm.every((n) => Number.isInteger(n) && n > 0)
+  )
+    return bad("confirm is a list of proposal ids");
+  try {
+    return NextResponse.json(
+      await confirmPins({
+        workspaceId,
+        kind,
+        confirm,
+        switchOver: switchOver === true,
+      })
+    );
+  } catch (error) {
+    return bad(error instanceof Error ? error.message : String(error));
+  }
+}

package/app/api/leads/route.test.ts

@@ -0,0 +1,95 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it } from "vitest";
+import { db } from "@/lib/db";
+import { setExperiment } from "@/lib/experiments";
+import { TRUST_HEADER } from "@/lib/security/auth";
+import { seedWorkspace } from "@/lib/orchestrator/testing";
+import { GET, POST } from "./route";
+import * as adopt from "./adopt/route";
+import * as proposals from "./proposals/route";
+
+const post = (
+  handler: (r: NextRequest) => Promise<Response>,
+  path: string,
+  body: unknown,
+  trust: string | null = "loopback"
+) =>
+  handler(
+    new NextRequest(`http://localhost/api/leads${path}`, {
+      method: "POST",
+      body: JSON.stringify(body),
+      headers: trust ? { [TRUST_HEADER]: trust } : {},
+    })
+  );
+
+beforeEach(() => {
+  db.prepare(`DELETE FROM settings WHERE key LIKE 'experiments.%'`).run();
+});
+
+describe("/api/leads", () => {
+  it("refuses while Leads is off, and without an approver", async () => {
+    const { workspace } = seedWorkspace();
+    const body = { workspaceId: workspace.id, kinds: ["marketing"] };
+    expect((await post(POST, "", body)).status).toBe(409);
+    expect(
+      (
+        await post(adopt.POST, "/adopt", {
+          ...body,
+          sessionId: "x",
+          kind: "marketing",
+        })
+      ).status
+    ).toBe(409);
+    setExperiment("leads", true);
+    expect((await post(POST, "", body, null)).status).toBe(403);
+    expect((await post(proposals.POST, "/proposals", body, null)).status).toBe(
+      403
+    );
+  });
+
+  it("adds leads and lists them", async () => {
+    setExperiment("leads", true);
+    const { workspace } = seedWorkspace();
+    const res = await post(POST, "", {
+      workspaceId: workspace.id,
+      kinds: ["marketing"],
+    });
+    expect(res.status).toBe(200);
+    expect(
+      (await res.json()).leads.map((l: { kind: string }) => l.kind)
+    ).toEqual(["tech", "marketing"]);
+    const list = await (
+      await GET(new NextRequest("http://localhost/api/leads"))
+    ).json();
+    expect(list.enabled).toBe(true);
+    expect(
+      list.workspaces.map((w: { workspaceId: string }) => w.workspaceId)
+    ).toContain(workspace.id);
+    const bad = await post(POST, "", {
+      workspaceId: workspace.id,
+      kinds: ["No Way"],
+    });
+    expect(bad.status).toBe(400);
+    expect(
+      (await post(POST, "", { workspaceId: "nope", kinds: [] })).status
+    ).toBe(404);
+  });
+
+  it("lists a lead's open proposals and refuses an unknown lead's", async () => {
+    setExperiment("leads", true);
+    const { workspace } = seedWorkspace();
+    await post(POST, "", { workspaceId: workspace.id, kinds: ["product"] });
+    const res = await proposals.GET(
+      new NextRequest(
+        `http://localhost/api/leads/proposals?workspaceId=${workspace.id}&kind=product`
+      )
+    );
+    expect((await res.json()).proposals).toEqual([]);
+    const none = await post(proposals.POST, "/proposals", {
+      workspaceId: workspace.id,
+      kind: "design",
+      confirm: [],
+    });
+    expect(none.status).toBe(400);
+  });
+});

package/app/api/leads/route.ts

@@ -0,0 +1,60 @@
+import { NextRequest, NextResponse } from "next/server";
+import { experimentOn } from "@/lib/experiments";
+import { requireApprover } from "@/lib/security/approver";
+import { getWorkspace } from "@/lib/workspaces";
+import { sessionById } from "@/lib/bus/targets";
+import { sessionWorkspace } from "@/lib/schedules/store";
+import { workspaceLeads, workspacesWithLeads } from "@/lib/leads/settings";
+import { addLeads, leadViews } from "@/lib/leads/home";
+
+const view = (workspaceId: string) => {
+  const w = workspaceLeads(workspaceId)!;
+  return {
+    workspaceId,
+    workspace: getWorkspace(workspaceId)?.name ?? "?",
+    chiefAutonomy: w.chiefAutonomy,
+    leads: leadViews(workspaceId),
+  };
+};
+
+// The workspaces with leads, and each one's leads. With `from` (a session),
+// only that session's workspace, unless `all`.
+export async function GET(request: NextRequest) {
+  const q = request.nextUrl.searchParams;
+  const from = sessionById(q.get("from"));
+  const own = from && !q.has("all") ? sessionWorkspace(from) : null;
+  const workspaces = workspacesWithLeads()
+    .filter((w) => !own || w.workspaceId === own)
+    .map((w) => view(w.workspaceId));
+  return NextResponse.json({
+    enabled: experimentOn("leads"),
+    workspace: own,
+    workspaces,
+  });
+}
+
+// "Add leads" on a workspace: its Tech lead (its orchestrator) and the
+// leads picked. Safe to repeat.
+export async function POST(request: NextRequest) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  if (!experimentOn("leads"))
+    return NextResponse.json(
+      { error: "Leads is off (Settings → Experiments)" },
+      { status: 409 }
+    );
+  const body = await request.json().catch(() => ({}));
+  const workspaceId =
+    typeof body.workspaceId === "string" ? body.workspaceId : "";
+  if (!getWorkspace(workspaceId))
+    return NextResponse.json({ error: "Unknown workspace" }, { status: 404 });
+  try {
+    addLeads(workspaceId, body.kinds ?? []);
+    return NextResponse.json(view(workspaceId));
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 400 }
+    );
+  }
+}

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

@@ -1,3 +1,4 @@
+import { isStandingRole } from "@/lib/leads/roles";
 import { NextResponse } from "next/server";
 import { queries, db, type Session } from "@/lib/db";
 import { FreshRefusal, freshStartChat } from "@/lib/chat/runner";
@@ -14,7 +15,7 @@ export async function POST(
   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)
+  if (!isStandingRole(session.role) && !session.task_brief)
     return NextResponse.json(
       { error: "Only an orchestrator or a task can start fresh" },
       { status: 400 }

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

@@ -1,3 +1,5 @@
+import { isStandingRole } from "@/lib/leads/roles";
+import { removeFork } from "@/lib/fork/scratch";
 import { removeSessionAttachments } from "@/lib/attachments/store";
 import { NextRequest, NextResponse } from "next/server";
 import { deletionRefusal } from "@/lib/orchestrator/home";
@@ -208,7 +210,7 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
     }
 
     let clearedGroup: string | null = null;
-    if (typeof body.projectId === "string" && !existing.role) {
+    if (typeof body.projectId === "string" && !isStandingRole(existing.role)) {
       if (!getProject(body.projectId))
         return NextResponse.json(
           { error: "Project not found" },
@@ -307,6 +309,12 @@ export async function DELETE(request: NextRequest, { params }: RouteParams) {
       }, `cleanup-worktree-${id}`);
     }
 
+    // A fork child's own folders go with it: deleting it is the ask.
+    runInBackground(async () => {
+      await agentEnded;
+      await removeFork(id);
+    }, `cleanup-fork-${id}`);
+
     // Also cleanup worker worktrees in background
     if (workers.length > 0) {
       for (const worker of workers) {

package/app/api/tmux/kill-all/route.ts

@@ -1,3 +1,4 @@
+import { isStandingRole } from "@/lib/leads/roles";
 import { NextResponse } from "next/server";
 import { getDb, queries, type Session } from "@/lib/db";
 import { getManagedSessionPattern } from "@/lib/providers/registry";
@@ -36,7 +37,7 @@ export async function POST() {
     // Delete every session from the database but the workspaces'
     // orchestrators, which are never swept.
     const dbSessions = (queries.getAllSessions(db).all() as Session[]).filter(
-      (s) => s.role !== "orchestrator"
+      (s) => !isStandingRole(s.role)
     );
     for (const session of dbSessions) {
       try {

package/app/api/workspaces/[id]/orchestrator/tools/route.test.ts

@@ -0,0 +1,43 @@
+import { NextRequest } from "next/server";
+import { describe, expect, it } from "vitest";
+import { seedWorkspace } from "@/lib/orchestrator/testing";
+import { TOKEN_HEADER } from "@/lib/orchestrator/tools";
+import { addLeads, getLead, standingToken } from "@/lib/leads/home";
+import { latestMemo } from "@/lib/leads/memos";
+import { POST } from "./route";
+
+const call = (w: string, token: string | null, tool: string, args = {}) =>
+  POST(
+    new NextRequest(`http://localhost/api/workspaces/${w}/orchestrator/tools`, {
+      method: "POST",
+      body: JSON.stringify({ tool, args }),
+      headers: token ? { [TOKEN_HEADER]: token } : {},
+    }),
+    { params: Promise.resolve({ id: w }) }
+  );
+
+describe("the standing sessions' tools", () => {
+  it("knows the caller by its token and keeps Tech's tools Tech's", async () => {
+    const { workspace } = seedWorkspace();
+    const w = workspace.id;
+    const [tech] = addLeads(w, ["marketing"]);
+    const marketing = getLead(w, "marketing")!;
+    const mine = standingToken(marketing.id);
+    expect((await call(w, null, "sessions")).status).toBe(403);
+    expect((await call(w, "wrong", "sessions")).status).toBe(403);
+    expect((await call(w, mine, "sessions")).status).toBe(200);
+    expect((await call(w, mine, "sign_off", { task: "x" })).status).toBe(403);
+    expect((await call(w, mine, "nonsense")).status).toBe(400);
+    const memo = await call(w, mine, "update_memo", { text: "Mine" });
+    expect(memo.status).toBe(200);
+    expect(latestMemo(w, "marketing")?.text).toBe("Mine");
+    // Tech's token isn't refused sign_off as not its own.
+    const techCall = await call(w, standingToken(tech.id), "sign_off", {
+      task: "x",
+    });
+    expect(techCall.status).toBe(400);
+    // Another workspace's token is no one here.
+    const other = seedWorkspace().workspace.id;
+    expect((await call(other, mine, "sessions")).status).toBe(403);
+  });
+});

package/app/api/workspaces/[id]/orchestrator/tools/route.ts

@@ -1,32 +1,35 @@
 import { NextRequest, NextResponse } from "next/server";
-import { isToolName, runTool } from "@/lib/orchestrator/serve";
-import { isOrchestratorToken } from "@/lib/orchestrator/home";
 import { TOKEN_HEADER } from "@/lib/orchestrator/tools";
+import { standingByToken } from "@/lib/leads/home";
+import { NotYours, runStandingTool, UnknownTool } from "@/lib/leads/tools";
 
 type RouteParams = { params: Promise<{ id: string }> };
 
 const LEGACY_ASK = "ask_saad";
 
-// The orchestrator chat's tools call here from its worker: plain text back.
-// Only that workspace's orchestrator worker holds the secret: other local
-// sessions are trusted by the network, not to act as the orchestrator.
+// The orchestrator chat's tools, and its leads', call here from their
+// workers: plain text back. Each standing session's worker holds its own
+// secret, which says who is calling: other local sessions are trusted by
+// the network, not to act as the orchestrator or a lead.
 export async function POST(request: NextRequest, { params }: RouteParams) {
   const { id } = await params;
-  if (!isOrchestratorToken(id, request.headers.get(TOKEN_HEADER)))
-    return new NextResponse("Not the orchestrator", { status: 403 });
+  const caller = standingByToken(id, request.headers.get(TOKEN_HEADER));
+  if (!caller) return new NextResponse("Not the orchestrator", { status: 403 });
   const body = await request.json().catch(() => ({}));
   const { args } = body;
   // A worker started before the rename still calls ask_saad.
   const tool = body.tool === LEGACY_ASK ? "ask_owner" : body.tool;
-  if (!isToolName(tool))
-    return NextResponse.json({ error: "Unknown tool" }, { status: 400 });
   try {
-    const text = await runTool(id, tool, args ?? {});
+    const text = await runStandingTool(id, caller, tool, args ?? {});
     return new NextResponse(text, {
       headers: { "Content-Type": "text/plain; charset=utf-8" },
     });
   } catch (error) {
+    if (error instanceof UnknownTool)
+      return NextResponse.json({ error: "Unknown tool" }, { status: 400 });
     const message = error instanceof Error ? error.message : String(error);
-    return new NextResponse(message, { status: 400 });
+    return new NextResponse(message, {
+      status: error instanceof NotYours ? 403 : 400,
+    });
   }
 }

package/components/Analyst/pair.ts

@@ -1,5 +1,6 @@
 "use client";
 
+import { isStandingRole } from "@/lib/leads/roles";
 import { useCallback } from "react";
 import { toast } from "sonner";
 import { usePanes } from "@/contexts/PaneContext";
@@ -72,7 +73,7 @@ export function useCanAddAnalyst(session: Session | null | undefined) {
   const paired = useSessionAnalyst(chat?.id).data;
   return (
     !!chat &&
-    !chat.role &&
+    !isStandingRole(chat.role) &&
     !chat.archived_at &&
     (chat.host_id || "local") === "local" &&
     chat.agent_role !== "analyst" &&

package/components/Chat/ChatPanel.tsx

@@ -649,6 +649,7 @@ export function ChatPanel({
         {orchestratorOf && (
           <NeedsYouStrip
             workspaceId={orchestratorOf}
+            sessionId={sessionId}
             chatWaiting={state === "waiting"}
             onGo={(item) => {
               if (item.kind === "ask") needsYouFocusActions.ask(item.ask.id);

package/components/Orchestrator/AskCard.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { TECH } from "@/lib/leads/types";
 import { useState, useSyncExternalStore } from "react";
 import { Check, CornerDownLeft, ExternalLink, X } from "lucide-react";
 import { Button } from "@/components/ui/button";
@@ -84,6 +85,11 @@ export function AskCard({
           {kind.label}
         </span>
       </div>
+      {ask.leadKind !== TECH && (
+        <p className="text-muted-foreground text-[11px] capitalize">
+          {ask.leadKind} lead
+        </p>
+      )}
       {ask.why && (
         <p
           className={cn(

package/components/Orchestrator/NeedsYouStrip.tsx

@@ -40,11 +40,16 @@ export interface NeedsYouActions {
 // it is resolved. Dismissing an item only hides it; an ask stays open.
 export const NeedsYouStrip = memo(function NeedsYouStrip({
   workspaceId,
+  sessionId,
   chatWaiting,
   onGo,
   onReply,
-}: NeedsYouActions & { workspaceId: string; chatWaiting: boolean }) {
-  const items = useNeedsYou(workspaceId, chatWaiting);
+}: NeedsYouActions & {
+  workspaceId: string;
+  sessionId: string;
+  chatWaiting: boolean;
+}) {
+  const items = useNeedsYou(workspaceId, sessionId, chatWaiting);
   const dismiss = useDismissNeedsYou(workspaceId);
   const cards = useApplyCard();
   // The learning card opened in place.

package/components/Pane/index.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { isStandingRole, isTechRole } from "@/lib/leads/roles";
 import { hasPrompt } from "@/lib/sessions/has-prompt";
 import { useTaskLogQuery } from "@/data/session-logs";
 import { SetupCard } from "@/components/Chat/SetupCard";
@@ -183,7 +184,7 @@ export const Pane = memo(function Pane({
   );
   const showGit = showGitToggle(isLocalSession, isGitRepo);
   const showGitDrawer =
-    gitDrawerOpen && showGit && session?.role !== "orchestrator";
+    gitDrawerOpen && showGit && !isStandingRole(session?.role);
   // The folder turned out not to be a repo: don't leave its git view open.
   useEffect(() => {
     if (isGitRepo !== false) return;
@@ -339,14 +340,11 @@ export const Pane = memo(function Pane({
         <ChatPanel
           sessionId={chat.id}
           sessionName={chat.name}
-          accessLocked={chat.role === "orchestrator"}
+          accessLocked={isStandingRole(chat.role)}
           freshStart={
-            (chat.role === "orchestrator" || !!chat.has_brief) &&
-            !chat.archived_at
-          }
-          orchestratorOf={
-            chat.role === "orchestrator" ? chat.workspace_id : null
+            (isStandingRole(chat.role) || !!chat.has_brief) && !chat.archived_at
           }
+          orchestratorOf={isTechRole(chat.role) ? chat.workspace_id : null}
           active={isActive && isFocused}
         />
       );

package/components/Schedules/ScheduleForm.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { isTechRole } from "@/lib/leads/roles";
 import { useEffect, useMemo, useState } from "react";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
@@ -226,7 +227,7 @@ export function ScheduleForm({
     .filter(
       (s) =>
         !s.archived_at &&
-        s.role !== "orchestrator" &&
+        !isTechRole(s.role) &&
         (!s.task_status || s.task_status === "running") &&
         (s.workspace_id ??
           (s.project_id ? projectWs.get(s.project_id) : null)) === workspace

package/components/SessionList/RowSubtitle.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { isTechRole } from "@/lib/leads/roles";
 import { Repeat, Layers, Pause, Hourglass } from "lucide-react";
 import { HostBadge } from "@/components/Hosts";
 import { rowGroup } from "@/lib/recipes/chip";
@@ -35,7 +36,7 @@ export function RowSubtitle({
   const ctx = useRowContext();
   // What its processes use, on a busy session: "3.1 cores · 4.2 GB".
   const usage = useSessionUsage(session.id);
-  if (session.role === "orchestrator") {
+  if (isTechRole(session.role)) {
     const ws = session.workspace_id ?? "";
     const overview = ctx.orchestrators.find((o) => o.workspaceId === ws);
     const parts = headerParts({

package/components/SessionList/SessionRow.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { isTechRole } from "@/lib/leads/roles";
 import { AGENT_ROLE_DEFS, isAgentRole } from "@/lib/models/agent-roles";
 import { isFork } from "@/lib/sessions/fork";
 import { memo, useState } from "react";
@@ -173,7 +174,7 @@ export const SessionRow = memo(function SessionRow({
           }
         />
       </RowShell>
-      {session.role === "orchestrator" && row.need && (
+      {isTechRole(session.role) && row.need && (
         <OrchestratorAsks workspaceId={session.workspace_id} />
       )}
       {(row.workers.length > 0 || !!row.quick?.length) && (

package/components/SessionList/useSidebarData.ts

@@ -1,5 +1,6 @@
 "use client";
 
+import { isStandingRole, isTechRole } from "@/lib/leads/roles";
 import { useCallback, useEffect, useMemo } from "react";
 import { useSnapshot } from "valtio";
 import type { Session } from "@/lib/db";
@@ -92,7 +93,7 @@ export function useSidebarData(
     const taskStates: Record<string, TaskState> = {};
     for (const t of tasks) taskStates[t.id] = t.state;
     const projectName = (s: Session) =>
-      s.role === "orchestrator"
+      isTechRole(s.role)
         ? `Orchestrator · ${workspaceName.get(s.workspace_id ?? "") ?? ""}`
         : (byId.get(s.project_id ?? "")?.name ?? "");
     const common = {
@@ -167,7 +168,11 @@ export function useSidebarData(
     const counts = new Map<string, number>();
     for (const s of sessions) {
       const ws = byId.get(s.project_id ?? "");
-      if (s.role || !ws || sessionStatuses?.[s.id]?.status !== "running")
+      if (
+        isStandingRole(s.role) ||
+        !ws ||
+        sessionStatuses?.[s.id]?.status !== "running"
+      )
         continue;
       counts.set(ws, (counts.get(ws) ?? 0) + 1);
     }
@@ -226,7 +231,7 @@ export function useSidebarData(
   // Orchestrator session id -> the workspace it serves, for tags and chips.
   const orchestratorKey = JSON.stringify(
     sessions
-      .filter((s) => s.role === "orchestrator")
+      .filter((s) => isTechRole(s.role))
       .map((s) => [
         s.id,
         workspaces.find((w) => w.id === s.workspace_id)?.name ?? s.name,

package/content/whats-new.json

@@ -2041,6 +2041,22 @@
       "area": "AgentOS",
       "text": "Mark a fork as done straight from the Forks list above the chat box.",
       "url": "https://github.com/saadnvd1/agent-os/pull/573"
+    },
+    {
+      "id": 574,
+      "date": "2026-11-02",
+      "kind": "fixed",
+      "area": "AgentOS",
+      "text": "Files a forked session writes are no longer deleted when it finishes.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/574"
+    },
+    {
+      "id": 576,
+      "date": "2026-11-02",
+      "kind": "improved",
+      "area": "AgentOS",
+      "text": "Heavy builds and test runs on Linux machines are now memory-capped, so one runaway command can no longer freeze the whole machine.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/576"
     }
   ]
 }

package/hooks/useNeedsYou.ts

@@ -1,5 +1,6 @@
 "use client";
 
+import { isStandingRole } from "@/lib/leads/roles";
 import { useMemo } from "react";
 import { useQuery } from "@tanstack/react-query";
 import { useSessionsQuery } from "@/data/sessions/queries";
@@ -15,9 +16,11 @@ import {
 } from "@/lib/orchestrator/needs-you-items";
 
 // Everything waiting on Saad in a workspace: its open asks and questions, the
-// tasks the sidebar marks as needing him, and its chat waiting on an answer.
+// tasks the sidebar marks as needing him, and this chat waiting on an answer
+// (keyed by the chat, so one lead's waiting chat never hides another's).
 export function useNeedsYou(
   workspaceId: string,
+  sessionId: string,
   chatWaiting: boolean
 ): NeedsYouItem[] {
   const overview = useOrchestratorOverview(workspaceId);
@@ -35,7 +38,10 @@ export function useNeedsYou(
     );
     return (sessions?.sessions ?? []).flatMap((s): TaskNeed[] => {
       const need = statuses?.statuses[s.id]?.need;
-      return !s.role && s.project_id && members.has(s.project_id) && need
+      return !isStandingRole(s.role) &&
+        s.project_id &&
+        members.has(s.project_id) &&
+        need
         ? [{ sessionId: s.id, name: s.name, need }]
         : [];
     });
@@ -49,8 +55,8 @@ export function useNeedsYou(
         tasks,
         cards: cardsOn ? (overview?.cards ?? []) : [],
         chatWaiting,
-        chatKey: `approval:${workspaceId}`,
+        chatKey: `approval:${sessionId}`,
       }),
-    [overview, tasks, cardsOn, chatWaiting, workspaceId]
+    [overview, tasks, cardsOn, chatWaiting, sessionId]
   );
 }

package/hooks/useOrchestratorHeader.ts

@@ -1,5 +1,6 @@
 "use client";
 
+import { isStandingRole } from "@/lib/leads/roles";
 import { useQuery } from "@tanstack/react-query";
 import { useSessionsQuery } from "@/data/sessions/queries";
 import { useProjectsQuery } from "@/data/projects/queries";
@@ -23,7 +24,7 @@ export function useWorkspaceRunning(workspaceId: string): number {
   );
   return (sessions?.sessions ?? []).filter(
     (s) =>
-      !s.role &&
+      !isStandingRole(s.role) &&
       s.project_id &&
       members.has(s.project_id) &&
       statuses?.statuses[s.id]?.status === "running"