@saadnvd1/agent-os 0.3.851 → 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/Chat/Forks.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { useState } from "react";
-import { GitFork, Square } from "lucide-react";
+import { CircleCheck, GitFork, Square } from "lucide-react";
 import { toast } from "sonner";
 import { useExperiment } from "@/data/experiments";
 import {
@@ -13,6 +13,7 @@ import {
 import { formatElapsed } from "@/lib/chat/elapsed";
 import { Button } from "@/components/ui/button";
 import { StatusPill } from "@/components/ui/status-pill";
+import { useDoneAction } from "@/components/SessionList/useDoneAction";
 import { SessionAnchor } from "./SessionAnchor";
 
 type Tone = "amber" | "muted" | "green" | "primary" | "red";
@@ -73,12 +74,14 @@ export const runningNote = (c: ChildView, now = Date.now()): string | null => {
 function Row({
   c,
   onStop,
+  onDone,
   stopping,
   again,
 }: {
   c: ChildView;
   again: ReturnType<typeof useRunAgain>;
   onStop: () => void;
+  onDone: () => void;
   stopping: boolean;
 }) {
   const { text, tone } = stateLabel(c);
@@ -144,6 +147,16 @@ function Row({
           <Square aria-hidden className="size-4" />
         </Button>
       )}
+      <Button
+        size="sm"
+        variant="ghost"
+        aria-label={`Mark fork ${c.n} done`}
+        data-tip="Done"
+        className="size-11 shrink-0"
+        onClick={onDone}
+      >
+        <CircleCheck aria-hidden className="size-4" />
+      </Button>
     </li>
   );
 }
@@ -154,10 +167,11 @@ export function ForksStrip({ sessionId }: { sessionId: string }) {
   const { data } = useForkChildren(sessionId, on);
   const cancel = useCancelForks(sessionId);
   const again = useRunAgain(sessionId);
+  const markDone = useDoneAction();
   const [collapsed, setCollapsed] = useState(false);
   if (!on || !data) return null;
   if (data.asChild) return <ForkOfBanner info={data.asChild} />;
-  const { children } = data;
+  const children = data.children.filter((c) => !c.done);
   if (!children.length) return null;
   const open = children.filter((c) => c.state !== "settled").length;
   const stop = (ref?: string) =>
@@ -206,6 +220,14 @@ export function ForksStrip({ sessionId }: { sessionId: string }) {
               stopping={cancel.isPending}
               again={again}
               onStop={() => stop(String(c.n))}
+              onDone={() =>
+                markDone({
+                  id: c.id,
+                  name: c.label,
+                  task_status: null,
+                  pr_status: null,
+                })
+              }
             />
           ))}
         </ul>

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/useDoneAction.ts

@@ -9,12 +9,18 @@ import {
 } from "@/data/done";
 import { useSettleSession } from "@/data/sessions/shelf";
 
+export type DoneTarget = Pick<
+  Session,
+  "id" | "name" | "task_status" | "pr_status"
+> &
+  Partial<Pick<Session, "settled_at">>;
+
 // Done from a session's menu: an open PR merges through the gates, after an
 // in-app confirmation; a failing gate comes back as an error toast naming it.
 export function useDoneAction() {
   const done = useDoneSession();
   const settle = useSettleSession();
-  const run = (session: Session, merges: boolean) => {
+  const run = (session: DoneTarget, merges: boolean) => {
     const id = toast.loading(
       merges ? `Merging ${session.name}…` : `Finishing ${session.name}…`
     );
@@ -38,7 +44,7 @@ export function useDoneAction() {
       onError: (e) => toast.error(e.message, { id, duration: 12000 }),
     });
   };
-  return (session: Session) => {
+  return (session: DoneTarget) => {
     const merges =
       session.task_status === "running" && session.pr_status === "open";
     if (!merges) return run(session, false);