@saadnvd1/agent-os 0.3.691 → 0.3.693

package/app/api/discovered-models/route.ts

@@ -0,0 +1,34 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { discoveredModels } from "@/lib/chat/discovered-models";
+import { getProject } from "@/lib/projects";
+
+const query = z.object({
+  agent: z.string().min(1),
+  projectId: z.string().optional(),
+  refresh: z.string().optional(),
+});
+
+// GET /api/discovered-models?agent=&projectId=&refresh=1 - the models an agent
+// reports for a project's folder, for a draft that has no session yet. Empty
+// for an agent with a fixed list.
+export async function GET(request: NextRequest) {
+  const parsed = query.safeParse(
+    Object.fromEntries(request.nextUrl.searchParams)
+  );
+  if (!parsed.success)
+    return NextResponse.json({ error: "agent is required" }, { status: 400 });
+  const { agent, projectId, refresh } = parsed.data;
+  const folder = projectId ? getProject(projectId)?.working_directory : null;
+  try {
+    return NextResponse.json({
+      models: await discoveredModels(agent, folder, refresh !== undefined),
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json(
+      { error: `Couldn't list the models: ${message}` },
+      { status: 502 }
+    );
+  }
+}

package/app/api/sessions/route.ts

@@ -61,6 +61,7 @@ export async function POST(request: NextRequest) {
     const { session, initialPrompt, repeat } = await launchSession({
       id: str(body.id),
       projectId: str(body.projectId),
+      workspaceId: str(body.workspaceId),
       project: projectRefOf(body.project),
       workingDirectory: str(body.workingDirectory),
       agentType:

package/components/Draft/DraftChips.tsx

@@ -98,11 +98,16 @@ export function DraftChips({
   }, [hostGone, onChange]);
 
   const pickProject = (id: string | null) => {
-    const next = newDraft(draft.id, real.find((p) => p.id === id) ?? null, {
-      agentType: draft.agentType,
-      model: draft.model,
-      access: draft.access,
-    });
+    const next = newDraft(
+      draft.id,
+      real.find((p) => p.id === id) ?? null,
+      {
+        agentType: draft.agentType,
+        model: draft.model,
+        access: draft.access,
+      },
+      { workspaceId: draft.workspaceId }
+    );
     onChange({
       ...next,
       openPr: !!id && draft.openPr,

package/components/Draft/DraftPanel.tsx

@@ -8,9 +8,11 @@ import { Button } from "@/components/ui/button";
 import type { ChatFile, ChatImage } from "@/lib/chat/events";
 import type { Project } from "@/lib/db";
 import { draftComposerKey, type Draft } from "@/lib/drafts";
-import { getModelOptions } from "@/lib/model-catalog";
+import { discoversModels } from "@/lib/model-catalog";
+import { useDiscoveredModels } from "@/data/agents";
 import { useHostsQuery } from "@/data/hosts";
 import { useGitCheck } from "@/data/git/queries";
+import { useSelectedWorkspace } from "@/hooks/useSelectedWorkspace";
 import { useLaunchSession } from "@/data/sessions";
 import { useCreateTask } from "@/data/tasks";
 import { usePanes } from "@/contexts/PaneContext";
@@ -18,6 +20,7 @@ import { setPendingPrompt } from "@/stores/initialPrompt";
 import { draftsActions, draftsStore, newDraft } from "@/stores/drafts";
 import { DraftChips } from "./DraftChips";
 import { DraftHeading } from "./DraftHeading";
+import { draftModels } from "./draftModels";
 
 // A new session before its first send: choices on top, a composer below.
 // Sending makes the session (and its worktree) and turns this tab into it.
@@ -41,7 +44,14 @@ export function DraftPanel({
   const { data: git } = useGitCheck(
     project && draft?.hostId === "local" ? project.working_directory : ""
   );
+  const discovers = !!draft && discoversModels(draft.agentType);
+  const found = useDiscoveredModels(
+    draft?.agentType ?? "",
+    draft?.projectId ?? null,
+    discovers
+  );
   const launch = useLaunchSession();
+  const { workspace } = useSelectedWorkspace();
   const createTask = useCreateTask();
   const [prefill, setPrefill] = useState<{ text: string; at: number }>();
   const pending = launch.isPending || createTask.isPending;
@@ -85,6 +95,7 @@ export function DraftPanel({
       }
       const { session, initialPrompt, repeat } = await launch.mutateAsync({
         projectId: project?.id ?? null,
+        workspaceId: draft.workspaceId ?? workspace?.id ?? null,
         id: draft.id,
         hostId:
           !project || draft.hostId !== project.host_id
@@ -148,7 +159,7 @@ export function DraftPanel({
           }
           onSend={(text, images, files) => void send(text, images, files)}
           onStop={() => {}}
-          models={getModelOptions(draft.agentType)}
+          models={draftModels(draft.agentType, found)}
           model={draft.model}
           onSetModel={(model) => draftsActions.update(draft.id, { model })}
           access={draft.openPr ? undefined : draft.access}

package/components/Draft/draftModels.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { draftModels } from "./draftModels";
+
+const qwen = { value: "ollama/qwen3", label: "Qwen 3" };
+
+describe("draftModels", () => {
+  it("lists the default and then what OpenCode reports", () => {
+    const list = draftModels("opencode", {
+      data: [qwen],
+      isPending: false,
+      isError: false,
+    });
+    expect(list.map((m) => m.value)).toEqual(["default", "ollama/qwen3"]);
+  });
+
+  it("says so beside the default while loading and on failure", () => {
+    const loading = draftModels("opencode", {
+      isPending: true,
+      isError: false,
+    });
+    const failed = draftModels("opencode", { isPending: false, isError: true });
+    expect(loading).toHaveLength(1);
+    expect(loading[0].label).toContain("loading");
+    expect(failed[0].label).toContain("couldn't");
+  });
+
+  it("keeps a fixed list as it is", () => {
+    const list = draftModels("claude", { isPending: true, isError: false });
+    expect(list.map((m) => m.value)).toContain("opus");
+  });
+});

package/components/Draft/draftModels.ts

@@ -0,0 +1,17 @@
+import type { ChatModel } from "@/lib/chat/events";
+import type { Draft } from "@/lib/drafts";
+import { discoversModels, getModelOptions } from "@/lib/model-catalog";
+
+// A fixed list, or the agent's default followed by what it reports; while it
+// loads or if it fails, the default alone says so.
+export function draftModels(
+  agentType: Draft["agentType"],
+  found: { data?: ChatModel[]; isPending: boolean; isError: boolean }
+): ChatModel[] {
+  const options = getModelOptions(agentType);
+  if (!discoversModels(agentType)) return options;
+  if (found.data) return [...options, ...found.data];
+  const [first, ...rest] = options;
+  const note = found.isError ? "couldn't list models" : "loading models…";
+  return [{ ...first, label: `${first.label} (${note})` }, ...rest];
+}

package/data/agents/index.ts

@@ -1,5 +1,6 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { AgentProbe } from "@/lib/agents/probe";
+import type { ChatModel } from "@/lib/chat/events";
 
 export const agentKeys = {
   all: ["agents"] as const,
@@ -35,3 +36,39 @@ export function useRecheckAgents() {
     onSuccess: (agents) => client.setQueryData(agentKeys.status(), agents),
   });
 }
+
+export const discoveredModelKeys = {
+  list: (agent: string, projectId: string | null) =>
+    [...agentKeys.all, "models", agent, projectId] as const,
+};
+
+// What an agent without a fixed list reports it can run, for a draft's
+// picker. Off for agents with a fixed list.
+export function useDiscoveredModels(
+  agent: string,
+  projectId: string | null,
+  enabled: boolean
+) {
+  const client = useQueryClient();
+  const key = discoveredModelKeys.list(agent, projectId);
+  const fetchModels = async (refresh: boolean) => {
+    const params = new URLSearchParams({ agent });
+    if (projectId) params.set("projectId", projectId);
+    if (refresh) params.set("refresh", "1");
+    const res = await fetch(`/api/discovered-models?${params}`);
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(data.error || "Couldn't list the models");
+    return data.models as ChatModel[];
+  };
+  const query = useQuery({
+    queryKey: key,
+    queryFn: () => fetchModels(false),
+    enabled,
+    staleTime: 5 * 60_000,
+    retry: false,
+  });
+  return {
+    ...query,
+    refresh: async () => client.setQueryData(key, await fetchModels(true)),
+  };
+}

package/data/sessions/queries.ts

@@ -182,6 +182,8 @@ export interface LaunchSessionInput {
   // The draft's id: the session's, and a resend's key to the same one.
   id: string;
   projectId: string | null;
+  // The workspace selected: where a session in no project is filed.
+  workspaceId?: string | null;
   // A scratch chat's machine; a project's sessions run where it lives, or
   // on a linked machine.
   hostId?: string;

package/hooks/useDraftRequests.ts

@@ -46,9 +46,15 @@ export function useDraftRequests(options: Options) {
   useEffect(() => {
     hydrateDrafts();
     const open = (projectId: string | null, openPr = false) => {
-      const { projects, viewing, show } = latest.current;
+      const { projects, viewing, show, workspaceId } = latest.current;
       const drafts = Object.values(draftsStore.drafts) as Draft[];
-      const found = reusableDraft(drafts, projectId, draftHasText, openPr);
+      const found = reusableDraft(
+        drafts,
+        projectId,
+        draftHasText,
+        openPr,
+        workspaceId
+      );
       if (found) return show(found.id);
       const from = viewing.draftId ? draftsStore.drafts[viewing.draftId] : null;
       const s = viewing.session;
@@ -58,7 +64,7 @@ export function useDraftRequests(options: Options) {
           ? { agentType: s.agent_type, model: s.model, access: s.chat_access }
           : {};
       const project = projects.find((p) => p.id === projectId) ?? null;
-      const draft = makeDraft(uuid(), project, carry, { openPr });
+      const draft = makeDraft(uuid(), project, carry, { openPr, workspaceId });
       draftsActions.put(draft);
       show(draft.id);
     };

package/lib/bus/read-scope.ts

@@ -60,7 +60,8 @@ function inScope(s: ReadableSession, scope: ReaderScope): boolean {
   if (s.role) return false;
   if (scope.workspaceId) {
     const p = s.project_id ? getProject(s.project_id) : null;
-    return !!p && p.workspace_id === scope.workspaceId;
+    // A session in no project is in the workspace it was started in.
+    return (p?.workspace_id ?? s.workspace_id) === scope.workspaceId;
   }
   return s.project_id === scope.projectId;
 }

package/lib/chat/discovered-models.ts

@@ -0,0 +1,87 @@
+import os from "os";
+import { discoversModels } from "../model-catalog";
+import { chatDriverFor } from "./drivers";
+import type { ChatModel } from "./events";
+
+const TTL_MS = 5 * 60_000;
+const TIMEOUT_MS = 30_000;
+
+interface Entry {
+  models: ChatModel[];
+  at: number;
+}
+const cache = new Map<string, Entry>();
+const loading = new Map<string, Promise<ChatModel[]>>();
+
+const expand = (p: string) => p.replace(/^~(?=$|\/)/, os.homedir());
+
+async function discover(agentType: string, cwd: string): Promise<ChatModel[]> {
+  const driver = chatDriverFor(agentType);
+  if (!driver) return [];
+  const ac = new AbortController();
+  const timer = setTimeout(
+    () => ac.abort(new Error("Discovery timed out")),
+    TIMEOUT_MS
+  );
+  timer.unref?.();
+  try {
+    const found = await Promise.race([
+      driver.discover({ cwd, env: {}, signal: ac.signal }),
+      new Promise<never>((_, reject) =>
+        ac.signal.addEventListener("abort", () => reject(ac.signal.reason), {
+          once: true,
+        })
+      ),
+    ]);
+    return found.models;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// The models an agent reports for a folder, cached for a few minutes.
+// `refresh` skips the cache; a failure throws and is never cached.
+export async function discoveredModels(
+  agentType: string,
+  folder: string | null | undefined,
+  refresh = false
+): Promise<ChatModel[]> {
+  if (!discoversModels(agentType)) return [];
+  const cwd = expand(folder?.trim() || "~");
+  const key = `${agentType}:${cwd}`;
+  const hit = cache.get(key);
+  if (!refresh && hit && Date.now() - hit.at < TTL_MS) return hit.models;
+  const running = loading.get(key);
+  if (running && !refresh) return running;
+  const run = discover(agentType, cwd)
+    .then((models) => {
+      cache.set(key, { models, at: Date.now() });
+      return models;
+    })
+    .finally(() => {
+      if (loading.get(key) === run) loading.delete(key);
+    });
+  loading.set(key, run);
+  return run;
+}
+
+export function clearDiscoveredModels(): void {
+  cache.clear();
+  loading.clear();
+}
+
+// Whether the agent reports this model. A failed discovery says no, so a
+// launch falls back to the agent's default rather than failing.
+export async function isDiscoveredModel(
+  agentType: string,
+  folder: string | null | undefined,
+  model: string
+): Promise<boolean> {
+  try {
+    return (await discoveredModels(agentType, folder)).some(
+      (m) => m.value === model
+    );
+  } catch {
+    return false;
+  }
+}

package/lib/drafts.ts

@@ -13,6 +13,8 @@ export interface Draft {
   id: string;
   // null: a scratch chat, in no project.
   projectId: string | null;
+  // The workspace selected when it was made: where a scratch chat is filed.
+  workspaceId?: string | null;
   hostId: string;
   agentType: AgentType;
   model: string;
@@ -55,13 +57,14 @@ export function newDraft(
   id: string,
   project: DraftProject | null,
   carry: Carry,
-  opts: { openPr?: boolean; now?: number } = {}
+  opts: { openPr?: boolean; now?: number; workspaceId?: string | null } = {}
 ): Draft {
   const real = project && !project.is_uncategorized ? project : null;
   const agentType = real?.agent_type ?? carry.agentType ?? "claude";
   return {
     id,
     projectId: real?.id ?? null,
+    workspaceId: real ? null : (opts.workspaceId ?? null),
     hostId: real?.host_id || "local",
     agentType,
     model: resolveModelForAgent(
@@ -82,11 +85,18 @@ export function reusableDraft(
   drafts: Draft[],
   projectId: string | null,
   hasText: (draftId: string) => boolean,
-  openPr = false
+  openPr = false,
+  workspaceId: string | null = null
 ): Draft | null {
+  // An empty scratch chat from another workspace would file this one's
+  // session there.
   return (
     drafts.find(
-      (d) => d.projectId === projectId && d.openPr === openPr && !hasText(d.id)
+      (d) =>
+        d.projectId === projectId &&
+        d.openPr === openPr &&
+        (projectId !== null || (d.workspaceId ?? null) === workspaceId) &&
+        !hasText(d.id)
     ) ?? null
   );
 }

package/lib/model-catalog.ts

@@ -1,5 +1,6 @@
 import type { AgentType } from "./providers";
 import { AGENT_DEFAULT_MODEL } from "./providers/registry";
+import { supportsChat } from "./chat/capabilities";
 
 export interface ModelOption {
   value: string;
@@ -48,6 +49,14 @@ const DEFAULT_MODEL_BY_AGENT: Partial<Record<AgentType, string>> = {
   gemini: "gemini-3.8-flash",
 };
 
+export function hasStaticModelCatalog(agentType: string): boolean {
+  return agentType in MODEL_OPTIONS_BY_AGENT;
+}
+
+// A chat agent with no fixed list: it reports what it can run itself.
+export const discoversModels = (agentType: string): boolean =>
+  supportsChat(agentType) && !hasStaticModelCatalog(agentType);
+
 export function getModelOptions(agentType: AgentType): ModelOption[] {
   return MODEL_OPTIONS_BY_AGENT[agentType] ?? AGENT_DEFAULT_OPTIONS;
 }

package/lib/projects.ts

@@ -278,11 +278,12 @@ export function deleteProject(id: string): boolean {
   const project = getProject(id);
   if (!project || project.is_uncategorized) return false;
 
-  // Move all sessions to Uncategorized
-  const sessions = queries.getSessionsByProject(db).all(id) as Session[];
-  for (const session of sessions) {
-    queries.updateSessionProject(db).run("uncategorized", session.id);
-  }
+  // Its sessions go to Uncategorized, staying in the project's workspace.
+  db.prepare(
+    `UPDATE sessions SET project_id = 'uncategorized', updated_at = datetime('now'),
+       workspace_id = CASE WHEN role IS NULL THEN ? ELSE workspace_id END
+     WHERE project_id = ?`
+  ).run(project.workspace_id ?? null, id);
 
   // Delete dev server instances
   queries.deleteDevServersByProject(db).run(id);
@@ -312,7 +313,27 @@ export function moveSessionToProject(
   sessionId: string,
   projectId: string
 ): void {
-  queries.updateSessionProject(db).run(projectId, sessionId);
+  const to = getProject(projectId);
+  const from = db
+    .prepare(
+      `SELECT p.workspace_id AS workspace_id, s.workspace_id AS own
+       FROM sessions s LEFT JOIN projects p ON p.id = s.project_id WHERE s.id = ?`
+    )
+    .get(sessionId) as
+    { workspace_id: string | null; own: string | null } | undefined;
+  db.transaction(() => {
+    queries.updateSessionProject(db).run(projectId, sessionId);
+    // A project's session follows the project; one left in none keeps the
+    // workspace it was in.
+    db.prepare(
+      `UPDATE sessions SET workspace_id = ? WHERE id = ? AND role IS NULL`
+    ).run(
+      to && !to.is_uncategorized
+        ? null
+        : (from?.workspace_id ?? from?.own ?? null),
+      sessionId
+    );
+  })();
 }
 
 /**

package/lib/sessions/launch.ts

@@ -11,10 +11,12 @@ import { randomUUID } from "crypto";
 import { db, queries, type Session } from "../db";
 import type { AgentType } from "../providers";
 import type { ChatAccess, ChatFile, ChatImage } from "../chat/events";
-import { resolveModelForAgent } from "../model-catalog";
+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 { getProject } from "../projects";
+import { getWorkspace } from "../workspaces";
 import { getHost, isRemoteHost } from "../hosts";
 import { hostLink } from "../hosts/remote-api";
 import { startOnPeer } from "../hosts/peer-actions";
@@ -77,6 +79,9 @@ export interface LaunchInput {
   // role's model (or `model`), not the interactive one's.
   startedBy?: string | null;
   startedVia?: StartVia;
+  // 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;
 }
@@ -177,6 +182,29 @@ export function launchSession(input: LaunchInput): Promise<Launched> {
   return p;
 }
 
+// The workspace a project-less session is filed under: the one it was started
+// from, else that of the orchestrator starting it. A workspace deleted since
+// the draft was made is dropped rather than failing the send.
+function homeWorkspace(input: LaunchInput): string | null {
+  const picked = input.workspaceId?.trim();
+  if (picked) return getWorkspace(picked) ? picked : null;
+  if (!input.startedBy) return null;
+  const by = db
+    .prepare(
+      `SELECT workspace_id FROM sessions WHERE id = ? AND role = 'orchestrator'`
+    )
+    .get(input.startedBy) as { workspace_id: string | null } | undefined;
+  return by?.workspace_id ?? null;
+}
+
+function setHome(id: string, workspaceId: string | null): void {
+  if (workspaceId)
+    db.prepare(`UPDATE sessions SET workspace_id = ? WHERE id = ?`).run(
+      workspaceId,
+      id
+    );
+}
+
 async function launch(input: LaunchInput, id: string): Promise<Launched> {
   const project = input.project
     ? await ensureProject(input.project)
@@ -184,6 +212,7 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
       ? getProject(input.projectId)
       : undefined;
   const scratch = !project || project.is_uncategorized;
+  const home = scratch ? homeWorkspace(input) : null;
   const hostId = (scratch ? input.hostId : null) || project?.host_id || "local";
   // A project here can start on a linked machine, which finds or clones it.
   const carried =
@@ -209,7 +238,7 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
   if (link) {
     if (input.images?.length || input.files?.length)
       throw new Error(`Images and files can't be sent to ${link.hostName} yet`);
-    return startOnPeer(link, {
+    const started = await startOnPeer(link, {
       id,
       project: scratch ? null : (project ?? null),
       ref: carried && project ? await projectRef(project) : undefined,
@@ -221,6 +250,10 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
       prompt: input.prompt?.trim(),
       view: input.view ?? DEFAULT_START_VIEW,
     });
+    setHome(started.session.id, home);
+    return home
+      ? { ...started, session: { ...started.session, workspace_id: home } }
+      : started;
   }
   const projectPath = expand(folder);
   if (scratch && projectPath === SCRATCH_DIR)
@@ -241,7 +274,7 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
   const routed =
     agentType === "claude" && (picked || !input.model?.trim()) && !remote
       ? resolveRole(role, {
-          workspaceId: project?.workspace_id,
+          workspaceId: project?.workspace_id ?? home,
           override: picked,
         })
       : null;
@@ -251,12 +284,18 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
     routed && (routed.provider.id === ANTHROPIC || view === "chat")
       ? routed
       : null;
+  const wanted = input.model?.trim() || project?.default_model;
+  // An agent without a static list runs what it reports for this folder.
+  const discovered =
+    !interactive &&
+    wanted &&
+    discoversModels(agentType) &&
+    (await isDiscoveredModel(agentType, projectPath, wanted));
   const model = interactive
     ? interactive.model
-    : resolveModelForAgent(
-        agentType,
-        input.model?.trim() || project?.default_model
-      );
+    : discovered && wanted
+      ? wanted
+      : resolveModelForAgent(agentType, wanted);
   const text = input.prompt?.trim() ?? "";
   const naming: Naming = text
     ? await nameFor(text, projectPath, input.name)
@@ -295,6 +334,7 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
     input.startedVia ?? (input.startedBy ? "orchestrator" : null),
     id
   );
+  setHome(id, home);
   if (interactive) setSessionModel(id, interactive);
   if (input.access)
     db.prepare(`UPDATE sessions SET chat_access = ? WHERE id = ?`).run(

package/lib/sidebar/shelves.ts

@@ -382,7 +382,9 @@ export function doneSummary(
 }
 
 // A workspace holds its projects' sessions and its own orchestrator; no
-// workspace selected means every session.
+// workspace selected means every session. A session in a project follows the
+// project, so moving it moves them; one in no project (scratch) belongs to the
+// workspace it was started in, kept on the session.
 export function inWorkspace(
   session: Pick<Session, "project_id" | "workspace_id" | "role">,
   workspaceOf: (projectId: string) => string | null | undefined,
@@ -391,9 +393,8 @@ export function inWorkspace(
   if (!workspaceId) return true;
   if (session.role === "orchestrator")
     return session.workspace_id === workspaceId;
-  return (
-    !!session.project_id && workspaceOf(session.project_id) === workspaceId
-  );
+  const byProject = session.project_id ? workspaceOf(session.project_id) : null;
+  return (byProject ?? session.workspace_id) === workspaceId;
 }
 
 // A workspace's projects, or every project when none is selected.

package/lib/workspaces.ts

@@ -115,6 +115,11 @@ export function deleteWorkspace(id: string): void {
       `UPDATE projects SET workspace_id = NULL WHERE workspace_id = ?`
     ).run(id);
     db.prepare(`DELETE FROM workspaces WHERE id = ?`).run(id);
+    // Sessions filed here by being started here go back to "All workspaces".
+    db.prepare(
+      `UPDATE sessions SET workspace_id = NULL
+       WHERE role IS NULL AND workspace_id = ?`
+    ).run(id);
     // Its orchestrator goes with it; a running worker idles out on its own.
     db.prepare(
       `DELETE FROM sessions WHERE role = 'orchestrator' AND workspace_id = ?`
@@ -128,6 +133,7 @@ export function deleteWorkspace(id: string): void {
   })();
 }
 
+// A project's sessions follow it, so moving one needs no change to them.
 export function setProjectWorkspace(
   projectId: string,
   workspaceId: string | null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.691",
+  "version": "0.3.693",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"