@saadnvd1/agent-os 0.3.700 → 0.3.723

package/lib/session-groups/reorderGroups.ts

@@ -0,0 +1,31 @@
+import { getDb } from "@/lib/db";
+import { listGroups } from "./store";
+import { GroupError, type SessionGroup } from "./types";
+
+// Sets a workspace's group order. `ids` may name only some of them (a move
+// up or down sends the whole list; a stale list from another device leaves
+// newer groups at the end), but never one from another workspace.
+export function reorderGroups(
+  workspaceId: string | null,
+  ids: unknown
+): SessionGroup[] {
+  if (!Array.isArray(ids) || ids.some((i) => typeof i !== "string"))
+    throw new GroupError("invalid", "ids is a list of group ids");
+  const current = listGroups(workspaceId);
+  const known = new Set(current.map((g) => g.id));
+  const wanted = [...new Set(ids as string[])];
+  const stranger = wanted.find((i) => !known.has(i));
+  if (stranger)
+    throw new GroupError("workspace", "A group is not in this workspace");
+  const order = [
+    ...wanted,
+    ...current.map((g) => g.id).filter((i) => !wanted.includes(i)),
+  ];
+  const db = getDb();
+  const set = db.prepare(
+    `UPDATE session_groups SET sort_order = ?, updated_at = datetime('now')
+     WHERE id = ? AND sort_order != ?`
+  );
+  db.transaction(() => order.forEach((id, i) => set.run(i, id, i)))();
+  return listGroups(workspaceId);
+}

package/lib/session-groups/resolveGroup.ts

@@ -0,0 +1,19 @@
+import { groupByName, listGroups } from "./store";
+import { GroupError, type SessionGroup } from "./types";
+
+// A group named by a caller (`aos --group`, an orchestrator tool): it must
+// exist in that workspace, and the error lists the ones that do.
+export function resolveGroup(
+  workspaceId: string | null,
+  name: string
+): SessionGroup {
+  const found = groupByName(workspaceId, name);
+  if (found) return found;
+  const names = listGroups(workspaceId).map((g) => `"${g.name}"`);
+  throw new GroupError(
+    "not-found",
+    names.length
+      ? `No group "${name.trim()}" in this workspace. Groups: ${names.join(", ")}`
+      : `No group "${name.trim()}": this workspace has no groups`
+  );
+}

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

@@ -0,0 +1,72 @@
+/**
+ * A crew: the sessions started in roles that work together. Its id is the
+ * session that began it, so a crew needs no table of its own.
+ */
+
+import { db } from "../db";
+import type { AgentRole } from "../models/agent-roles";
+
+const crewOf = (id: string | null | undefined): string | null =>
+  id
+    ? ((
+        db.prepare(`SELECT crew_id FROM session_rows WHERE id = ?`).get(id) as
+          { crew_id: string | null } | undefined
+      )?.crew_id ?? null)
+    : null;
+
+// Puts a session in a role and a crew: the one named, else its starter's (or
+// its calling session's), else a new one it begins.
+export function joinCrew(
+  id: string,
+  role: AgentRole,
+  from: {
+    crewId?: string | null;
+    startedBy?: string | null;
+    parent?: string | null;
+  }
+): string {
+  const crew =
+    from.crewId || crewOf(from.startedBy) || crewOf(from.parent) || id;
+  db.prepare(
+    `UPDATE sessions SET agent_role = ?, crew_id = ? WHERE id = ?`
+  ).run(role, crew, id);
+  return crew;
+}
+
+export interface CrewMember {
+  id: string;
+  name: string;
+  agentRole: string | null;
+  model: string | null;
+  modelProvider: string | null;
+  agentType: string;
+  taskStatus: string | null;
+}
+
+export function crewMembers(crewId: string): CrewMember[] {
+  return (
+    db
+      .prepare(
+        `SELECT id, name, agent_role, model, model_provider, agent_type, task_status
+           FROM session_rows WHERE crew_id = ? AND archived_at IS NULL
+          ORDER BY created_at`
+      )
+      .all(crewId) as {
+      id: string;
+      name: string;
+      agent_role: string | null;
+      model: string | null;
+      model_provider: string | null;
+      agent_type: string;
+      task_status: string | null;
+    }[]
+  ).map((r) => ({
+    id: r.id,
+    name: r.name,
+    agentRole: r.agent_role,
+    model: r.model,
+    modelProvider: r.model_provider,
+    agentType: r.agent_type,
+    taskStatus: r.task_status,
+  }));
+}

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";
@@ -15,6 +16,9 @@ import { discoversModels, resolveModelForAgent } from "../model-catalog";
 import { isDiscoveredModel } from "../chat/discovered-models";
 import { parseOverride, resolveRole, setSessionModel } from "../models/resolve";
 import { ANTHROPIC } from "../models/roles";
+import { joinCrew } from "./crew";
+import { prepareRoleStart } from "../models/agent-binding";
+import { isAgentRole, roleBrief, type AgentRole } from "../models/agent-roles";
 import { getProject } from "../projects";
 import { getWorkspace } from "../workspaces";
 import { getHost, isRemoteHost } from "../hosts";
@@ -82,8 +86,16 @@ 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;
+  // Start it in a role: the model comes from the role's binding (or
+  // `model`), and its brief joins the instructions.
+  agentRole?: AgentRole | null;
+  // The crew it joins: the id of the session that began it.
+  crewId?: string | null;
+  // When the role's model is down, start on the role's fallback instead.
+  useFallback?: boolean;
+  // The user's group it starts in (lib/session-groups).
+  groupId?: string;
 }
 
 export interface Launched {
@@ -259,7 +271,17 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
   if (scratch && projectPath === SCRATCH_DIR)
     await fs.promises.mkdir(SCRATCH_DIR, { recursive: true });
 
-  const agentType = input.agentType;
+  if (input.agentRole && (remote || !isAgentRole(input.agentRole)))
+    throw new Error("A role session runs on this machine");
+  const roleStart = input.agentRole
+    ? await prepareRoleStart(input.agentRole, {
+        workspaceId: project?.workspace_id ?? home,
+        projectId: project && !project.is_uncategorized ? project.id : null,
+        override: input.model?.trim() || null,
+        useFallback: input.useFallback,
+      })
+    : null;
+  const agentType: AgentType = roleStart?.agentType ?? input.agentType;
   const view =
     input.view === "terminal" || !supportsChat(agentType) || remote
       ? "terminal"
@@ -271,20 +293,30 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
   const picked = input.startedBy ? parseOverride(input.model) : null;
   if (picked && typeof picked !== "string")
     throw new Error(`model: a session takes one "provider/model"`);
-  const routed =
-    agentType === "claude" && (picked || !input.model?.trim()) && !remote
+  const routed = roleStart
+    ? roleStart.agentType === "claude"
+      ? roleStart.routed
+      : null
+    : agentType === "claude" && (picked || !input.model?.trim()) && !remote
       ? resolveRole(role, {
           workspaceId: project?.workspace_id ?? home,
           override: picked,
         })
       : null;
-  if (picked && routed && routed.provider.id !== ANTHROPIC && view !== "chat")
+  if (
+    (picked || roleStart) &&
+    routed &&
+    routed.provider.id !== ANTHROPIC &&
+    view !== "chat"
+  )
     throw new Error("Another provider's models run only as a chat");
   const interactive =
     routed && (routed.provider.id === ANTHROPIC || view === "chat")
       ? routed
       : null;
-  const wanted = input.model?.trim() || project?.default_model;
+  const wanted = roleStart
+    ? roleStart.model
+    : input.model?.trim() || project?.default_model;
   // An agent without a static list runs what it reports for this folder.
   const discovered =
     !interactive &&
@@ -293,9 +325,11 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
     (await isDiscoveredModel(agentType, projectPath, wanted));
   const model = interactive
     ? interactive.model
-    : discovered && wanted
-      ? wanted
-      : resolveModelForAgent(agentType, wanted);
+    : roleStart
+      ? roleStart.model
+      : discovered && wanted
+        ? wanted
+        : resolveModelForAgent(agentType, wanted);
   const text = input.prompt?.trim() ?? "";
   const naming: Naming = text
     ? await nameFor(text, projectPath, input.name)
@@ -316,8 +350,10 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
       cwd,
       input.parentSessionId ?? null,
       model,
-      input.systemPrompt ?? null,
-      input.groupPath ?? "sessions",
+      [input.systemPrompt, roleBrief(input.agentRole)]
+        .filter(Boolean)
+        .join("\n\n") || null,
+      "sessions",
       agentType,
       input.autoApprove || input.access === "full" ? 1 : 0,
       project?.id ?? "uncategorized",
@@ -335,6 +371,13 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
     id
   );
   setHome(id, home);
+  if (input.agentRole)
+    joinCrew(id, input.agentRole, {
+      crewId: input.crewId,
+      startedBy: input.startedBy,
+      parent: input.parentSessionId,
+    });
+  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/settings-url.ts

@@ -9,6 +9,7 @@ export const SETTINGS_SECTIONS = [
   "approvals",
   "workspaces",
   "models",
+  "agent-roles",
   "devices",
   "shares",
   "notifications",

package/lib/share/markdown.ts

@@ -83,13 +83,13 @@ export function htmlToMarkdown(html: string, demote = 0): string {
 }
 
 /** A fenced block whose fence is longer than any backtick run inside. */
-function fenced(text: string): string {
+export function fenced(text: string, lang = ""): string {
   const longest = Math.max(
     2,
     ...(text.match(/`+/g) ?? []).map((m) => m.length)
   );
   const fence = "`".repeat(longest + 1);
-  return `${fence}\n${text}\n${fence}`;
+  return `${fence}${lang}\n${text}\n${fence}`;
 }
 
 function itemToMarkdown(item: SnapshotItem): string {

package/lib/share/redact.ts

@@ -97,10 +97,12 @@ function sub(
 
 export function redactForShare(
   input: string,
-  ctx: ShareContext = NO_CONTEXT
+  ctx: ShareContext = NO_CONTEXT,
+  opts: { only?: Kind[] } = {}
 ): { text: string; hits: Hits } {
   const hits = noHits();
   let t = input;
+  const on = (k: Kind) => !opts.only || opts.only.includes(k);
 
   // 1. Credentials by shape.
   t = sub(t, PRIVATE_KEY_BLOCK, SECRET, hits, "secret");
@@ -143,7 +145,7 @@ export function redactForShare(
   }
 
   // 3. Home paths, and the account name before an @.
-  if (ctx.home.length > 1)
+  if (on("path") && ctx.home.length > 1)
     t = sub(
       t,
       new RegExp(escape(ctx.home) + "(?![\\w.-])", "g"),
@@ -151,8 +153,8 @@ export function redactForShare(
       hits,
       "path"
     );
-  t = sub(t, new RegExp(HOME.source, "g"), "~", hits, "path");
-  if (ctx.user.length > 2)
+  if (on("path")) t = sub(t, new RegExp(HOME.source, "g"), "~", hits, "path");
+  if (on("path") && ctx.user.length > 2)
     t = sub(
       t,
       new RegExp(`\\b${escape(ctx.user)}(?=@)`, "g"),
@@ -162,14 +164,16 @@ export function redactForShare(
     );
 
   // 4. Addresses.
-  t = sub(t, IPV4, "[ip]", hits, "ip", (m) => KEEP_IPV4.has(m));
-  t = sub(t, IPV6, "[ip]", hits, "ip", (m) => KEEP_IPV6.has(m));
+  if (on("ip")) {
+    t = sub(t, IPV4, "[ip]", hits, "ip", (m) => KEEP_IPV4.has(m));
+    t = sub(t, IPV6, "[ip]", hits, "ip", (m) => KEEP_IPV6.has(m));
+  }
 
   // 5. This machine's names, and private-network suffixes.
   const names = [...new Set(ctx.hosts.filter((h) => h.length > 2))].sort(
     (a, b) => b.length - a.length
   );
-  if (names.length)
+  if (on("host") && names.length)
     t = sub(
       t,
       new RegExp(
@@ -180,11 +184,13 @@ export function redactForShare(
       hits,
       "host"
     );
-  t = sub(t, CONNECT_HOST, "[host]", hits, "host");
-  t = sub(t, LOCAL_HOST, "[host]", hits, "host");
+  if (on("host")) {
+    t = sub(t, CONNECT_HOST, "[host]", hits, "host");
+    t = sub(t, LOCAL_HOST, "[host]", hits, "host");
+  }
 
   // 6. Email addresses.
-  t = sub(t, EMAIL, "[email]", hits, "email");
+  if (on("email")) t = sub(t, EMAIL, "[email]", hits, "email");
 
   return { text: t, hits };
 }

package/lib/share/render.tsx

@@ -60,7 +60,7 @@ const components: Components = {
   img: ({ alt }) => <span>[image{alt ? `: ${alt}` : ""}]</span>,
 };
 
-function Markdown({ text }: { text: string }) {
+export function Markdown({ text }: { text: string }) {
   return (
     <ReactMarkdown remarkPlugins={[remarkGfm]} components={components}>
       {text}

package/lib/share/snapshot.ts

@@ -44,7 +44,7 @@ export interface Snapshot {
 
 export const MAX_TOOL_INPUT = 4_000;
 export const MAX_TOOL_OUTPUT = 20_000;
-const HIDDEN_FILE = "[contents of a secret file hidden]";
+export const HIDDEN_FILE = "[contents of a secret file hidden]";
 const NO_IMAGE = "[image not shared]";
 
 const clip = (s: string, max: number) =>
@@ -55,7 +55,7 @@ const clip = (s: string, max: number) =>
 const excerptOf = (s: string) => s.replace(/\s+/g, " ").trim().slice(0, 120);
 
 // Every string in a tool's input, to see whether it names a secret file.
-function strings(v: unknown, out: string[] = []): string[] {
+export function strings(v: unknown, out: string[] = []): string[] {
   if (typeof v === "string") out.push(v);
   else if (Array.isArray(v)) v.forEach((x) => strings(x, out));
   else if (v && typeof v === "object")

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

@@ -16,11 +16,13 @@ export type RowMenuItem =
   | "open-recipe"
   | "copy-link"
   | "share"
+  | "export"
   | "fork"
   | "fresh-start"
   | "new-conversation"
   | "move-machine"
   | "move-project"
+  | "move-group"
   | "check-ins"
   | "save-recipe"
   | "run-again"
@@ -120,7 +122,11 @@ export function rowMenu(input: RowMenuInput): RowMenuPlan {
       input.hasCard && "card",
       input.recipeRun && "open-recipe",
     ]),
-    ...group("share", ["copy-link", s.view === "chat" && "share"]),
+    ...group("share", [
+      "copy-link",
+      s.view === "chat" && "share",
+      s.view === "chat" && "export",
+    ]),
     ...group("restart", [
       s.agent_type === "claude" && agentRow && live && "fork",
       agentRow && live && "fresh-start",
@@ -133,6 +139,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 &&