@saadnvd1/agent-os 0.3.698 → 0.3.715

package/lib/session-groups/route.ts

@@ -0,0 +1,32 @@
+import { NextResponse } from "next/server";
+import type { z } from "zod";
+import { GROUP_STATUS, GroupError } from "./types";
+
+// Runs a group action for a route: a body that fails its schema is a 400, a
+// GroupError becomes its status code.
+export async function groupRoute<S extends z.ZodType>(
+  request: Request,
+  schema: S,
+  act: (body: z.infer<S>) => unknown
+): Promise<NextResponse> {
+  const parsed = schema.safeParse(await request.json().catch(() => null));
+  if (!parsed.success)
+    return NextResponse.json(
+      { error: parsed.error.issues[0]?.message ?? "Bad request" },
+      { status: 400 }
+    );
+  return run(() => act(parsed.data));
+}
+
+export function run(act: () => unknown): NextResponse {
+  try {
+    return NextResponse.json(act());
+  } catch (err) {
+    if (err instanceof GroupError)
+      return NextResponse.json(
+        { error: err.message, code: err.code },
+        { status: GROUP_STATUS[err.code] }
+      );
+    throw err;
+  }
+}

package/lib/session-groups/store.ts

@@ -0,0 +1,85 @@
+import { getDb } from "@/lib/db";
+import { GroupError, NAME_MAX, type SessionGroup } from "./types";
+
+interface GroupRow extends Omit<SessionGroup, "collapsed"> {
+  collapsed: number;
+  deleted_at: string | null;
+}
+
+const COLUMNS = `id, workspace_id, name, sort_order, collapsed, created_at,
+  updated_at, deleted_at`;
+
+const toGroup = ({ deleted_at: _, ...row }: GroupRow): SessionGroup => ({
+  ...row,
+  collapsed: !!row.collapsed,
+});
+
+export function cleanName(name: unknown): string {
+  const trimmed =
+    typeof name === "string" ? name.trim().replace(/\s+/g, " ") : "";
+  if (!trimmed) throw new GroupError("invalid", "A group needs a name");
+  if (trimmed.length > NAME_MAX)
+    throw new GroupError(
+      "invalid",
+      `A group name is at most ${NAME_MAX} characters`
+    );
+  return trimmed;
+}
+
+// Live groups (not deleted), in the order to show them within a workspace.
+export function listGroups(workspaceId?: string | null): SessionGroup[] {
+  const rows = (
+    workspaceId === undefined
+      ? getDb()
+          .prepare(
+            `SELECT ${COLUMNS} FROM session_groups WHERE deleted_at IS NULL
+             ORDER BY sort_order, created_at`
+          )
+          .all()
+      : getDb()
+          .prepare(
+            `SELECT ${COLUMNS} FROM session_groups WHERE deleted_at IS NULL
+               AND COALESCE(workspace_id, '') = COALESCE(?, '')
+             ORDER BY sort_order, created_at`
+          )
+          .all(workspaceId)
+  ) as GroupRow[];
+  return rows.map(toGroup);
+}
+
+// Live groups' names by id, for labelling.
+export function groupNames(): Map<string, string> {
+  return new Map(listGroups().map((g) => [g.id, g.name]));
+}
+
+// Any group by id, deleted or not, with whether it is deleted.
+export function findGroup(
+  id: string
+): (SessionGroup & { deleted: boolean }) | null {
+  const row = getDb()
+    .prepare(`SELECT ${COLUMNS} FROM session_groups WHERE id = ?`)
+    .get(id) as GroupRow | undefined;
+  return row ? { ...toGroup(row), deleted: !!row.deleted_at } : null;
+}
+
+// A live group by id, or the error a caller should surface.
+export function liveGroup(id: unknown): SessionGroup {
+  const group = typeof id === "string" ? findGroup(id) : null;
+  if (!group) throw new GroupError("not-found", "Group not found");
+  if (group.deleted) throw new GroupError("deleted", "That group was deleted");
+  return group;
+}
+
+export function groupByName(
+  workspaceId: string | null,
+  name: string
+): SessionGroup | null {
+  const row = getDb()
+    .prepare(
+      `SELECT ${COLUMNS} FROM session_groups
+       WHERE deleted_at IS NULL AND lower(name) = lower(?)
+         AND COALESCE(workspace_id, '') = COALESCE(?, '')`
+    )
+    .get(name.trim(), workspaceId) as GroupRow | undefined;
+  return row ? toGroup(row) : null;
+}

package/lib/session-groups/types.ts

@@ -0,0 +1,25 @@
+export type { SessionGroup } from "@/lib/sidebar/shelves";
+
+export type GroupErrorCode =
+  "not-found" | "duplicate" | "workspace" | "invalid" | "deleted";
+
+// Thrown for anything the caller got wrong; routes map the code to a status.
+export class GroupError extends Error {
+  constructor(
+    readonly code: GroupErrorCode,
+    message: string
+  ) {
+    super(message);
+    this.name = "GroupError";
+  }
+}
+
+export const GROUP_STATUS: Record<GroupErrorCode, number> = {
+  "not-found": 404,
+  duplicate: 409,
+  workspace: 409,
+  invalid: 400,
+  deleted: 409,
+};
+
+export const NAME_MAX = 60;

package/lib/session-groups/updateGroup.ts

@@ -0,0 +1,35 @@
+import { getDb } from "@/lib/db";
+import { cleanName, groupByName, liveGroup } from "./store";
+import { GroupError, type SessionGroup } from "./types";
+
+// Rename and fold. Folding is stored here so every device agrees.
+export function updateGroup(
+  id: string,
+  patch: { name?: unknown; collapsed?: unknown }
+): SessionGroup {
+  const group = liveGroup(id);
+  const sets: string[] = [];
+  const args: (string | number)[] = [];
+  if (patch.name !== undefined) {
+    const clean = cleanName(patch.name);
+    const clash = groupByName(group.workspace_id, clean);
+    if (clash && clash.id !== id)
+      throw new GroupError("duplicate", `There is already a group "${clean}"`);
+    sets.push("name = ?");
+    args.push(clean);
+  }
+  if (patch.collapsed !== undefined) {
+    if (typeof patch.collapsed !== "boolean")
+      throw new GroupError("invalid", "collapsed must be a boolean");
+    sets.push("collapsed = ?");
+    args.push(patch.collapsed ? 1 : 0);
+  }
+  if (sets.length)
+    getDb()
+      .prepare(
+        `UPDATE session_groups SET ${sets.join(", ")},
+           updated_at = datetime('now') WHERE id = ?`
+      )
+      .run(...args, id);
+  return liveGroup(id);
+}

package/lib/session-groups/workspace.ts

@@ -0,0 +1,21 @@
+import { getDb } from "@/lib/db";
+
+// The workspace a session belongs to: its project's, else the one kept on the
+// session (an orchestrator, or a scratch session in no project). Same rule as
+// inWorkspace in lib/sidebar/shelves, read from the database.
+export function sessionWorkspaceId(
+  sessionId: string
+): string | null | undefined {
+  const row = getDb()
+    .prepare(
+      `SELECT s.role AS role, s.workspace_id AS own, p.workspace_id AS byProject
+       FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
+       WHERE s.id = ?`
+    )
+    .get(sessionId) as
+    | { role: string | null; own: string | null; byProject: string | null }
+    | undefined;
+  if (!row) return undefined;
+  if (row.role === "orchestrator") return row.own;
+  return row.byProject ?? row.own;
+}

package/lib/sessions/end.ts

@@ -4,6 +4,7 @@ import { waitForExit } from "../chat/worker/client";
 import { endTmuxSession } from "../tmux/end";
 import { releaseOnEnd, shutTaskSimulators } from "../simulator";
 import { forgetPlanWait } from "../models/plan-step";
+import { kickWaits } from "../bus/waits/kick";
 
 type Agent = Pick<Session, "id" | "host_id" | "tmux_name"> &
   Partial<Pick<Session, "worktree_path" | "branch_name">>;
@@ -20,4 +21,6 @@ export async function endSessionAgent(s: Agent): Promise<void> {
   shutTaskSimulators(s);
   void waitForExit(s.id).catch(() => {});
   await endTmuxSession(s.host_id, s.tmux_name);
+  // Whoever waits on it is told now, not at the next sweep.
+  kickWaits();
 }

package/lib/sessions/launch.ts

@@ -3,6 +3,7 @@
  * then (for a worktree) the setup in the background, then the first message.
  */
 
+import { fileInGroup } from "../session-groups/assignSessions";
 import { agentosHome } from "../agentos-home";
 import type { StartVia } from "../tasks/starter";
 import fs from "fs";
@@ -82,8 +83,9 @@ export interface LaunchInput {
   // The workspace selected when it was started. A session in a project
   // follows the project; one in none keeps this (see inWorkspace).
   workspaceId?: string | null;
-  groupPath?: string;
   systemPrompt?: string | null;
+  // The user's group it starts in (lib/session-groups).
+  groupId?: string;
 }
 
 export interface Launched {
@@ -317,7 +319,7 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
       input.parentSessionId ?? null,
       model,
       input.systemPrompt ?? null,
-      input.groupPath ?? "sessions",
+      "sessions",
       agentType,
       input.autoApprove || input.access === "full" ? 1 : 0,
       project?.id ?? "uncategorized",
@@ -335,6 +337,7 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
     id
   );
   setHome(id, home);
+  if (input.groupId) fileInGroup(id, input.groupId);
   if (interactive) setSessionModel(id, interactive);
   if (input.access)
     db.prepare(`UPDATE sessions SET chat_access = ? WHERE id = ?`).run(

package/lib/sidebar/rollup.ts

@@ -28,6 +28,7 @@ export function rollups(
   const rows = flatten([
     ...shelves.orchestrators,
     ...shelves.pinned,
+    ...shelves.groups.flatMap((g) => g.rows),
     ...shelves.needsYou,
     ...shelves.working,
     ...shelves.inReview,

package/lib/sidebar/row-menu.ts

@@ -21,6 +21,7 @@ export type RowMenuItem =
   | "new-conversation"
   | "move-machine"
   | "move-project"
+  | "move-group"
   | "check-ins"
   | "save-recipe"
   | "run-again"
@@ -133,6 +134,7 @@ export function rowMenu(input: RowMenuInput): RowMenuPlan {
     ...group("move", [
       input.machineTargets > 0 && "move-machine",
       agentRow && input.otherProjects > 0 && live && "move-project",
+      agentRow && "move-group",
     ]),
     ...group("automate", [
       input.hasWorkspace &&

package/lib/sidebar/shelves.ts

@@ -1,6 +1,6 @@
 // The sidebar's one flat list, sorted onto shelves: the workspace's pinned
-// orchestrator, Pinned, Needs you, Working, In review, Ongoing, Snoozed, then
-// Done. Client-safe: no database.
+// orchestrator, Pinned, the user's groups, Needs you, Working, In review,
+// Ongoing, Snoozed, then Done. Client-safe: no database.
 import type { Session } from "@/lib/db/types";
 import { fromSqliteTime } from "@/lib/session-meta";
 import type { PrStage } from "@/lib/tasks/pr-stage";
@@ -42,6 +42,25 @@ export interface RowStatus {
   detail?: string | null;
 }
 
+// A named shelf the user files sessions into (lib/session-groups). Native
+// reads the same shape from GET /api/sessions.
+export interface SessionGroup {
+  id: string;
+  workspace_id: string | null;
+  name: string;
+  sort_order: number;
+  collapsed: boolean;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface GroupShelf {
+  group: SessionGroup;
+  rows: SidebarRow[];
+  // What a folded header still has to say.
+  rollup: { needsYou: number };
+}
+
 export interface SidebarRow {
   session: Session;
   status: RowStatus | undefined;
@@ -60,8 +79,11 @@ export interface SidebarRow {
   activeAt: number;
   // While snoozed: when it wakes (ms).
   wakesAt?: number;
-  // A plain session in Done: marked by hand, or settled by itself.
+  // A plain session in Done: marked by hand, or settled by itself. In a
+  // group, "auto" only mutes the row: it stays where it was put.
   settled?: "manual" | "auto";
+  // The group it belongs to, even while Done holds it (Reopen goes back).
+  groupName?: string;
   // Its agent is being stopped, is stopped, or is starting again
   // (lib/tasks/pause): until is when it resumes by itself (ms), null: when
   // someone resumes it.
@@ -76,6 +98,8 @@ export interface Shelves {
   // Each shown workspace's current orchestrator, while it's pinned.
   orchestrators: SidebarRow[];
   pinned: SidebarRow[];
+  // The shown groups in order, empty ones too.
+  groups: GroupShelf[];
   needsYou: SidebarRow[];
   working: SidebarRow[];
   inReview: SidebarRow[];
@@ -145,6 +169,9 @@ export interface ShelfInput {
   currentOrchestrators?: ReadonlySet<string>;
   // Only the sessions this orchestrator session started.
   startedBy?: string | null;
+  // The live groups to show, in the order to draw them. A session in any
+  // other group id is filed by status as if it had none.
+  groups?: readonly SessionGroup[];
   // The clock (ms): wakes and 3-day settles are read from it.
   now?: number;
 }
@@ -274,6 +301,24 @@ function toRow(input: ShelfInput, session: Session, now: number): SidebarRow {
   };
 }
 
+// Where a row goes when nothing the user did holds it: what it needs, what
+// it's doing, then how finished it is. Sets settled on a plain session in Done.
+function statusShelf(
+  row: SidebarRow,
+  now: number
+): "needsYou" | "working" | "inReview" | "ongoing" | "snoozed" | "done" {
+  if (row.need) return "needsYou";
+  // A stopped agent is not working, whatever its last status said.
+  if (row.paused?.state === "paused") return "snoozed";
+  if (row.working) return "working";
+  if (row.wakesAt) return "snoozed";
+  if (row.task || row.session.task_status) return quietShelf(row.task);
+  const settled = settledHow(row.session, now);
+  if (!settled) return "ongoing";
+  row.settled = settled;
+  return "done";
+}
+
 export function buildShelves(input: ShelfInput): Shelves {
   const now = input.now ?? Date.now();
   const rows = input.sessions
@@ -314,6 +359,7 @@ export function buildShelves(input: ShelfInput): Shelves {
   const shelves: Shelves = {
     orchestrators: [],
     pinned: [],
+    groups: [],
     needsYou: [],
     working: [],
     inReview: [],
@@ -321,26 +367,36 @@ export function buildShelves(input: ShelfInput): Shelves {
     snoozed: [],
     done: [],
   };
+  const filtered = !!input.query?.trim() || !!input.projectId;
+  const grouped = new Map<string, GroupShelf>(
+    (input.groups ?? []).map((group) => [
+      group.id,
+      { group, rows: [], rollup: { needsYou: 0 } },
+    ])
+  );
   for (const row of top) {
     const { pinned, role, id } = row.session;
     const current = !!input.currentOrchestrators?.has(id);
+    const mine = grouped.get(row.session.session_group_id ?? "");
+    // Named on a row outside its group (Pinned, Done); inside, the header says it.
+    if (mine) row.groupName = mine.group.name;
     if (pinned && current) shelves.orchestrators.push(row);
     else if (pinned && role !== "orchestrator") shelves.pinned.push(row);
-    else if (row.need) shelves.needsYou.push(row);
-    // A stopped agent is not working, whatever its last status said.
-    else if (row.paused?.state === "paused") shelves.snoozed.push(row);
-    else if (row.working) shelves.working.push(row);
-    else if (row.wakesAt) shelves.snoozed.push(row);
-    else if (row.task || row.session.task_status)
-      shelves[quietShelf(row.task)].push(row);
     else {
-      const settled = settledHow(row.session, now);
-      if (settled) {
-        row.settled = settled;
-        shelves.done.push(row);
-      } else shelves.ongoing.push(row);
+      const shelf = statusShelf(row, now);
+      // Membership beats status. Only finished work goes on to Done (it keeps
+      // its group); a session that merely went quiet stays, muted.
+      if (mine && (shelf !== "done" || row.settled === "auto")) {
+        delete row.groupName;
+        mine.rows.push(row);
+        if (row.need) mine.rollup.needsYou++;
+      } else shelves[shelf].push(row);
     }
   }
+  for (const shelf of grouped.values()) {
+    shelf.rows.sort((a, b) => b.activeAt - a.activeAt);
+    if (!filtered || shelf.rows.length > 0) shelves.groups.push(shelf);
+  }
   shelves.orchestrators.sort(oldestFirst);
   shelves.pinned.sort(oldestFirst);
   shelves.needsYou.sort(newestFirst);
@@ -357,6 +413,24 @@ export function buildShelves(input: ShelfInput): Shelves {
   return shelves;
 }
 
+// The groups to draw, in the order to draw them: by workspace (in the order
+// given; groups of no workspace last), then by their own order.
+export function orderGroups(
+  groups: readonly SessionGroup[],
+  workspaceOrder: readonly string[]
+): SessionGroup[] {
+  const rank = (g: SessionGroup) => {
+    const at = g.workspace_id ? workspaceOrder.indexOf(g.workspace_id) : -1;
+    return at < 0 ? workspaceOrder.length : at;
+  };
+  return [...groups].sort(
+    (a, b) =>
+      rank(a) - rank(b) ||
+      a.sort_order - b.sort_order ||
+      a.created_at.localeCompare(b.created_at)
+  );
+}
+
 // Done shows 10 at first, then 25 more per "Show more".
 export const doneLimit = (pages: number) =>
   DONE_FIRST_PAGE + Math.max(0, pages) * DONE_PAGE;
@@ -424,6 +498,7 @@ export function sameRow(a: SidebarRow, b: SidebarRow): boolean {
     a.paused?.until === b.paused?.until &&
     a.paused?.note === b.paused?.note &&
     a.settled === b.settled &&
+    a.groupName === b.groupName &&
     a.workers.length === b.workers.length &&
     a.workers.every((w, i) => sameRow(w, b.workers[i])) &&
     (a.quick?.length ?? 0) === (b.quick?.length ?? 0) &&

package/lib/sidebar/visible-order.ts

@@ -11,6 +11,10 @@ export interface ShelfFolds {
 // to the pages shown. SessionShelves renders from this too, so the two agree.
 export function shownShelves(shelves: Shelves, folds: ShelfFolds) {
   return {
+    groups: shelves.groups.map((g) => ({
+      ...g,
+      rows: g.group.collapsed ? [] : g.rows,
+    })),
     snoozed: folds.snoozedCollapsed ? [] : shelves.snoozed,
     done: folds.doneCollapsed
       ? []
@@ -32,6 +36,7 @@ export function visibleSessionIds(
   return flatten([
     ...shelves.orchestrators,
     ...shelves.pinned,
+    ...shown.groups.flatMap((g) => g.rows),
     ...shelves.needsYou,
     ...shelves.working,
     ...shelves.inReview,

package/lib/tasks/hold-checks.ts

@@ -16,7 +16,7 @@ import { DEFAULT_PRIORITY, type Priority } from "./schedule-types";
 import { machineHolds, holdReason, type Hold } from "./holds";
 import { heavyNeeds, meetsNeeds, needsOf, type Need } from "./placement";
 import { expandHome } from "./session";
-import { afterLabel, hasFinished } from "./queue-rows";
+import { afterLabel, afterMet, hasFinished } from "./queue-rows";
 import type { QueueRow } from "./queue-types";
 import type { PauseBy } from "./schedule-types";
 
@@ -46,6 +46,8 @@ export const autoHold = (
 
 // `after X`: the task it waits on hasn't finished.
 export function afterHold(r: QueueRow): Hold | null {
+  if (r.after_claim && !afterMet(r))
+    return { code: "after_claim", text: `After ${afterLabel(r)}` };
   if (!r.after_task || hasFinished(r.after_task)) return null;
   return {
     code: "after",

package/lib/tasks/holds.ts

@@ -64,6 +64,7 @@ export type MachineCode =
 export type Hold =
   | { code: "after"; text: string }
   | { code: "after_any"; text: string }
+  | { code: "after_claim"; text: string }
   | { code: "orch_paused"; text: string }
   | { code: "window"; text: string }
   | {
@@ -80,6 +81,7 @@ export type Hold =
 export const HOLD_ORDER: readonly WaitCode[] = [
   "after",
   "after_any",
+  "after_claim",
   "orch_paused",
   "window",
   "needs",
@@ -95,6 +97,7 @@ export const HOLD_ORDER: readonly WaitCode[] = [
 const CLEARS_BY_ITSELF: Record<WaitCode, boolean> = {
   after: true,
   after_any: true,
+  after_claim: true,
   orch_paused: false,
   window: true,
   needs: false,

package/lib/tasks/index.ts

@@ -47,6 +47,7 @@ import {
   type TaskState,
 } from "./state";
 import { expandHome, prFor, storedPR, taskSessions } from "./session";
+import { fileInGroup } from "../session-groups/assignSessions";
 import { InProgressError, type OrchestratedBundle } from "./move-bundle";
 import { holdFor, mayHold } from "./held";
 import { orchestratorOf, recordStart, type StartVia } from "./starter";
@@ -169,6 +170,8 @@ export async function createTask(opts: {
   // How its agent runs: as a chat (the default, DEFAULT_START_VIEW) or in
   // a terminal.
   view?: StartView;
+  // The user's group it joins as it starts (lib/session-groups).
+  groupId?: string;
   // Started by another machine's orchestrator, which this one holds it for
   // (held.ts): that machine's paired device and its description of the task.
   held?: { device: string; orchestrated: OrchestratedBundle };
@@ -292,6 +295,7 @@ async function startTask(
       startedByDevice: opts.held?.device ?? opts.startedByDevice,
     });
     if (opts.pieceId) claimPiece(opts.pieceId, session.id);
+    if (opts.groupId) fileInGroup(session.id, opts.groupId);
     opts.onCreated?.(session.id);
     return session;
   }
@@ -416,6 +420,7 @@ async function startTask(
     throw error;
   }
   if (opts.held) holdFor(id, opts.held.device, opts.held.orchestrated);
+  if (opts.groupId) fileInGroup(id, opts.groupId);
   opts.onCreated?.(id);
   void naming.refine?.(id);
 

package/lib/tasks/queue-rows.ts

@@ -6,6 +6,7 @@
 import { db, type Session } from "../db";
 import { getProject } from "../projects";
 import { getWorkspace } from "../workspaces";
+import { liveClaim } from "../claims/store";
 import { queuedLabel } from "./queue-held";
 import type { Group } from "./schedule";
 import type { QueueRow } from "./queue-types";
@@ -106,6 +107,8 @@ export function stillWorking(taskId: string): boolean {
 }
 
 export function afterMet(r: QueueRow): boolean {
+  // A claim is over when it is gone, released or expired.
+  if (r.after_claim && liveClaim(r.after_claim)) return false;
   if (r.after_task && !hasFinished(r.after_task)) return false;
   if (r.after_any && !r.after_any_used) {
     const ids = JSON.parse(r.after_any) as string[];
@@ -171,7 +174,7 @@ export const waitingIn = (workspaceId: string) =>
       .prepare(
         `SELECT COUNT(*) AS n FROM task_queue q JOIN projects p ON p.id = q.project_id
          WHERE q.status = 'queued' AND p.workspace_id = ?
-           AND q.after_task IS NULL AND q.after_any IS NULL
+           AND q.after_task IS NULL AND q.after_any IS NULL AND q.after_claim IS NULL
            AND q.plan_only IS NULL`
       )
       .get(workspaceId) as { n: number }
@@ -180,6 +183,10 @@ export const waitingIn = (workspaceId: string) =>
 export const label = queuedLabel;
 
 export function afterLabel(r: QueueRow): string | null {
+  if (r.after_claim) {
+    const c = liveClaim(r.after_claim);
+    return c ? `${c.goal} on ${c.originName}` : "a work claim";
+  }
   if (r.after_task) {
     const s = sessionOf(r.after_task);
     const q = s ? null : row(r.after_task);

package/lib/tasks/queue-start.ts

@@ -138,6 +138,7 @@ export async function startRow(
     startedVia: (r.started_via ??
       (r.started_by ? "session" : "person")) as StartVia,
     view: r.view ?? undefined,
+    groupId: r.session_group_id ?? undefined,
     agent: (r.agent_type as AgentType | null) ?? undefined,
     baseBranch: r.base_branch ?? undefined,
     hostId: placed?.hostId ?? r.host_id ?? undefined,

package/lib/tasks/queue-types.ts

@@ -26,6 +26,8 @@ export interface QueueRow {
   started_by_device: string | null;
   started_via: string | null;
   view: "chat" | "terminal" | null;
+  // The user's group it joins when it starts (lib/session-groups).
+  session_group_id: string | null;
   agent_type: string | null;
   base_branch: string | null;
   host_id: string | null;
@@ -37,6 +39,9 @@ export interface QueueRow {
   // The finish (a task id) this "after any" waiter took; one finish lets one
   // waiter go (a unique index keeps it so).
   after_any_used: string | null;
+  // A work claim (lib/claims) it waits on, by claim id, until the claim is
+  // released or expires.
+  after_claim: string | null;
   priority: Priority;
   // What it needs from a machine, as JSON, when the starter said.
   machine_needs: string | null;
@@ -102,10 +107,13 @@ export interface QueueRequest {
   // The waiting plan piece it builds, claimed for its queue id.
   pieceId?: number;
   view?: "chat" | "terminal";
+  // The user's group it joins when it starts: a live group of its workspace.
+  groupId?: string;
   agent?: AgentType;
   baseBranch?: string;
   hostId?: string;
-  // A task's id or name, or "any" for whichever running task finishes first.
+  // A task's id or name, "any" for whichever running task finishes first, or
+  // "claim:<id>" for a work claim on a linked machine.
   after?: string;
   // Set when the orchestrator starts it.
   originWorkspaceId?: string;