@saadnvd1/agent-os 0.3.468 → 0.3.470

package/README.md

@@ -872,7 +872,11 @@ it may do on its own, and the lines that always come back to you as asks.
 - **Tools:** `sessions` (every session's status, activity, task, PR, CI and
   stack position), `read` (the end of a terminal or chat) and `cards` (the
   linked boards' cards), plus acting tools: `send`, `start_task`,
-  `start_session`, `stack`, `stack_status`, `land`, `drop`, `stop`, `done`, `note`,
+  `start_session`, `stack`, `stack_status`, `land`, `drop`, `stop`, `done`,
+  `add_project` (a git repository on the machine becomes a project of the
+  workspace, or the project already at that path moves in from no workspace;
+  folders that hold secrets and projects of another workspace are refused),
+  `note`,
   `rule_add`, `rule_remove`, `review`, `sign_off`, `arm`, `disarm` and `ask_saad`. All are served in-process to its chat, refuse
   any target outside its workspace, and validate their arguments. The one
   exception is other orchestrators: `orchestrators` lists every workspace and
@@ -882,6 +886,29 @@ it may do on its own, and the lines that always come back to you as asks.
   approve, answer an ask or pass a gate. The route
   they call answers only the orchestrator's worker, by a per-orchestrator
   secret. Its shell runs only `aos` commands that read.
+- **Files:** it reads anywhere and writes (Write, Edit, NotebookEdit) anywhere
+  except a project repository, a task worktree (`~/.agent-os/worktrees`),
+  AgentOS's own install and state (all of `~/.agent-os` but its own folder),
+  secret files (`.env`, keys, `~/.ssh`, `~/.aws`, `gh`'s token, tokenvault and
+  the like; the list the merge gates use for secrets handling,
+  `lib/secret-paths.ts`), and files that make something run: dotfiles and
+  dot-folders at the top of its home (shell, git, Claude and tool config, the
+  usage brake's `limits.json`), `~/Library`, `/Library/LaunchAgents` and
+  `LaunchDaemons`, git's `core.hooksPath` folders (yours and each project's),
+  the folders on `PATH`, and any `.git`, `.claude`, `.mcp.json`, `CLAUDE.md`
+  or `AGENTS.md`, since writing one would give it a shell or run code in
+  AgentOS's own git; and the temporary checkouts a review or rebase runs in.
+  Code changes to a project go through a task, so its PR still passes CI,
+  review and scope. It is a list of exceptions, not of allowed places: a
+  script a hook or scheduled job runs from an ordinary folder can still be
+  written, so an orchestrator misled by text it read could run code that way.
+  That's accepted: task agents can already write anywhere, so an allowlist
+  on the orchestrator alone would buy little.
+  Its chat worker checks every write in a PreToolUse hook before it runs, on
+  the path with symlinks and `..` resolved as the system will, and refuses
+  with the reason; the repositories are read from the database on each write,
+  so a project added since counts. A worker from before an update picks the
+  new permissions up at its handover to the new build.
 - **Brakes:** every start is refused, with the reason, while 4 sessions run in
   the workspace, after 6 starts in an hour (`orch_max_running` and
   `orch_max_starts_per_hour` on `workspaces`), or when the account's 5-hour

package/app/api/projects/clone/route.ts

@@ -2,14 +2,16 @@ import { NextRequest, NextResponse } from "next/server";
 import { startClone } from "@/lib/project-add";
 
 // POST /api/projects/clone - starts cloning { url } into { parent } on a
-// machine; GET /api/projects/clone/:job follows it.
+// machine, in { workspaceId } when given; GET /api/projects/clone/:job
+// follows it.
 export async function POST(request: NextRequest) {
   try {
     const body = await request.json();
     const job = startClone(
       typeof body.hostId === "string" ? body.hostId : "local",
       String(body.parent ?? "~"),
-      String(body.url ?? "").trim()
+      String(body.url ?? "").trim(),
+      typeof body.workspaceId === "string" ? body.workspaceId : null
     );
     return NextResponse.json({ job }, { status: 202 });
   } catch (error) {

package/app/api/projects/init/route.test.ts

@@ -0,0 +1,46 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { describe, expect, it } from "vitest";
+import type { NextRequest } from "next/server";
+import { getProject } from "@/lib/projects";
+import { createWorkspace } from "@/lib/workspaces";
+import { POST } from "./route";
+
+const post = (body: object) =>
+  POST({ json: async () => body } as unknown as NextRequest);
+
+describe("POST /api/projects/init", () => {
+  it("answers a folder that's already a project with 409 and it, and moves it on moveExisting", async () => {
+    const a = createWorkspace("Route A");
+    const b = createWorkspace("Route B");
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "aos-init-route-"));
+
+    const made = await post({ path: dir, workspaceId: a.id });
+    expect(made.status).toBe(201);
+    const { project } = await made.json();
+    expect(getProject(project.id)?.workspace_id).toBe(a.id);
+
+    const again = await post({ path: dir, workspaceId: b.id });
+    expect(again.status).toBe(409);
+    expect((await again.json()).existing).toEqual({
+      id: project.id,
+      name: project.name,
+      workspaceId: a.id,
+    });
+
+    // Only a real true moves it.
+    expect(
+      (await post({ path: dir, workspaceId: b.id, moveExisting: "true" }))
+        .status
+    ).toBe(409);
+    const moved = await post({
+      path: dir,
+      workspaceId: b.id,
+      moveExisting: true,
+    });
+    expect(moved.status).toBe(201);
+    expect((await moved.json()).project.id).toBe(project.id);
+    expect(getProject(project.id)?.workspace_id).toBe(b.id);
+  });
+});

package/app/api/projects/init/route.ts

@@ -1,22 +1,42 @@
 import { NextRequest, NextResponse } from "next/server";
-import { addFolder, initProject } from "@/lib/project-add";
+import { addFolder, initProject, ProjectExistsError } from "@/lib/project-add";
 
 // POST /api/projects/init - a project from a folder that exists ({ path }),
-// or a new one from a name ({ parent, name }: folder, git init, first commit).
+// or a new one from a name ({ parent, name }: folder, git init, first commit),
+// in { workspaceId } when given. A folder that's already a project answers
+// 409 with it, unless { moveExisting } moves it into the workspace.
 export async function POST(request: NextRequest) {
   try {
     const body = await request.json();
     const hostId = typeof body.hostId === "string" ? body.hostId : "local";
+    const workspaceId =
+      typeof body.workspaceId === "string" ? body.workspaceId : null;
     const project =
       typeof body.path === "string"
-        ? await addFolder(hostId, body.path)
+        ? (
+            await addFolder(hostId, body.path, {
+              workspaceId,
+              moveExisting: body.moveExisting === true,
+            })
+          ).project
         : await initProject(
             hostId,
             String(body.parent ?? "~"),
-            String(body.name ?? "")
+            String(body.name ?? ""),
+            workspaceId
           );
     return NextResponse.json({ project }, { status: 201 });
   } catch (error) {
+    if (error instanceof ProjectExistsError) {
+      const { id, name, workspace_id } = error.project;
+      return NextResponse.json(
+        {
+          error: error.message,
+          existing: { id, name, workspaceId: workspace_id },
+        },
+        { status: 409 }
+      );
+    }
     const message = error instanceof Error ? error.message : String(error);
     return NextResponse.json(
       { error: message.trim().split("\n").pop() },

package/components/CommandPalette/CommandPalette.tsx

@@ -51,6 +51,8 @@ function PaletteBody() {
 
   const results = useMemo(() => {
     if (query.trim()) return matchCommands(all, query);
+    // A picker shows every choice; it's the whole list.
+    if (picker) return all;
     // With no query, long groups are cut short so every group shows.
     const seen = new Map<string, number>();
     return all.filter((c) => {
@@ -58,7 +60,7 @@ function PaletteBody() {
       seen.set(c.group, n);
       return n <= GROUP_PREVIEW;
     });
-  }, [all, query]);
+  }, [all, query, picker]);
   const highlighted = Math.min(active, Math.max(results.length - 1, 0));
 
   useEffect(() => {

package/components/CommandPalette/useAppCommands.ts

@@ -29,6 +29,7 @@ import { sidebarUi, sidebarUiActions } from "@/stores/sidebarUi";
 import { tasksUiActions } from "@/stores/tasksUi";
 import { newDraft } from "@/stores/drafts";
 import { useAddProject } from "@/components/Projects/AddProject/useAddProject";
+import { useAddExistingProject } from "@/components/Projects/AddProject/useAddExistingProject";
 import { usageUiActions } from "@/stores/usageUi";
 import { settingsCommands } from "@/components/Settings/commands";
 import { DRAFT_KEYS } from "@/lib/drafts";
@@ -66,6 +67,7 @@ export function useAppCommands({
   const current = workspaces.find((w) => w.id === workspaceId) ?? null;
   const dark = resolvedTheme?.startsWith("dark") ?? false;
   const addProject = useAddProject();
+  const addExisting = useAddExistingProject();
 
   const app: PaletteCommand[] = [
     {
@@ -113,6 +115,14 @@ export function useAppCommands({
     },
     ...(current
       ? [
+          {
+            id: "app.add-project-to-workspace",
+            title: `Add project to ${current.name}`,
+            group: "Actions",
+            keywords: ["existing", "move", "workspace", "project"],
+            icon: FolderPlus,
+            run: () => addExisting(current),
+          },
           {
             id: "app.orchestrator",
             title: `Open ${current.name}'s orchestrator`,

package/components/Projects/AddProject/AddProjectDialog.tsx

@@ -14,6 +14,7 @@ import { useHostNames } from "@/data/hosts";
 import { FolderForm } from "./FolderForm";
 import { CloneForm } from "./CloneForm";
 import { NameForm } from "./NameForm";
+import { WorkspacePick } from "./WorkspacePick";
 
 const TITLES = {
   folder: "Open a folder",
@@ -21,8 +22,9 @@ const TITLES = {
   name: "New project",
 };
 
-// The last step of "Add project" (⌘K): a folder, a clone or a name. Once
-// it's made, a draft opens in it.
+// The last step of "Add project" (⌘K): a folder, a clone or a name, into
+// the sidebar's workspace unless changed here. Once it's made, a draft
+// opens in it.
 export function AddProjectDialog() {
   const { open } = useSnapshot(addProjectUi);
   const hostNames = useHostNames();
@@ -43,14 +45,32 @@ export function AddProjectDialog() {
               : "this machine"}
           </DialogDescription>
         </DialogHeader>
+        {open && (
+          <WorkspacePick
+            workspaceId={open.workspaceId}
+            onChange={addProjectActions.setWorkspace}
+          />
+        )}
         {open?.kind === "folder" && (
-          <FolderForm hostId={open.hostId} onDone={done} />
+          <FolderForm
+            hostId={open.hostId}
+            workspaceId={open.workspaceId}
+            onDone={done}
+          />
         )}
         {open?.kind === "clone" && (
-          <CloneForm hostId={open.hostId} onDone={done} />
+          <CloneForm
+            hostId={open.hostId}
+            workspaceId={open.workspaceId}
+            onDone={done}
+          />
         )}
         {open?.kind === "name" && (
-          <NameForm hostId={open.hostId} onDone={done} />
+          <NameForm
+            hostId={open.hostId}
+            workspaceId={open.workspaceId}
+            onDone={done}
+          />
         )}
       </DialogContent>
     </Dialog>

package/components/Projects/AddProject/CloneForm.tsx

@@ -9,9 +9,11 @@ import { ParentPicker } from "./ParentPicker";
 
 export function CloneForm({
   hostId,
+  workspaceId,
   onDone,
 }: {
   hostId: string;
+  workspaceId: string | null;
   onDone: (projectId: string) => void;
 }) {
   const [url, setUrl] = useState("");
@@ -29,7 +31,7 @@ export function CloneForm({
       className="space-y-3"
       onSubmit={(e) => {
         e.preventDefault();
-        start.mutate({ hostId, parent, url: url.trim() });
+        start.mutate({ hostId, parent, url: url.trim(), workspaceId });
       }}
     >
       <Input

package/components/Projects/AddProject/FolderForm.tsx

@@ -2,18 +2,52 @@
 
 import { useState } from "react";
 import { Button } from "@/components/ui/button";
-import { useInitProject } from "@/data/projects";
+import {
+  ProjectExistsError,
+  useInitProject,
+  type ExistingProject,
+} from "@/data/projects";
+import { useWorkspacesQuery } from "@/data/workspaces";
 import { FolderBrowser } from "./FolderBrowser";
 
 export function FolderForm({
   hostId,
+  workspaceId,
   onDone,
 }: {
   hostId: string;
+  workspaceId: string | null;
   onDone: (projectId: string) => void;
 }) {
   const [path, setPath] = useState("~");
   const init = useInitProject();
+  const [existing, setExisting] = useState<ExistingProject | null>(null);
+  const add = (moveExisting = false) =>
+    init.mutate(
+      { hostId, path, workspaceId, moveExisting },
+      {
+        onSuccess: (p) => onDone(p.id),
+        onError: (e) =>
+          e instanceof ProjectExistsError && setExisting(e.existing),
+      }
+    );
+
+  if (existing)
+    return (
+      <AlreadyAProject
+        existing={existing}
+        workspaceId={workspaceId}
+        pending={init.isPending}
+        error={init.error instanceof ProjectExistsError ? null : init.error}
+        onMove={() => add(true)}
+        onOpen={() => onDone(existing.id)}
+        onBack={() => {
+          setExisting(null);
+          init.reset();
+        }}
+      />
+    );
+
   return (
     <div className="space-y-3">
       <FolderBrowser hostId={hostId} path={path} onNavigate={setPath} />
@@ -23,12 +57,72 @@ export function FolderForm({
       <Button
         className="h-11 w-full md:h-9"
         disabled={init.isPending}
-        onClick={() =>
-          init.mutate({ hostId, path }, { onSuccess: (p) => onDone(p.id) })
-        }
+        onClick={() => add()}
       >
         {init.isPending ? "Adding…" : "Use this folder"}
       </Button>
     </div>
   );
 }
+
+// The folder is a project already: move it into the workspace this adds
+// to, or just start in it.
+function AlreadyAProject({
+  existing,
+  workspaceId,
+  pending,
+  error,
+  onMove,
+  onOpen,
+  onBack,
+}: {
+  existing: ExistingProject;
+  workspaceId: string | null;
+  pending: boolean;
+  error: Error | null;
+  onMove: () => void;
+  onOpen: () => void;
+  onBack: () => void;
+}) {
+  const { data: workspaces = [] } = useWorkspacesQuery();
+  const nameOf = (id: string | null) =>
+    workspaces.find((w) => w.id === id)?.name ?? null;
+  const from = nameOf(existing.workspaceId);
+  const to = nameOf(workspaceId);
+  const canMove = !!to && existing.workspaceId !== workspaceId;
+  return (
+    <div className="space-y-3">
+      <p className="text-sm">
+        <span className="font-medium">{existing.name}</span> is already a
+        project, {from ? `in ${from}` : "in no workspace"}.
+      </p>
+      {error && <p className="text-destructive text-sm">{error.message}</p>}
+      <div className="flex flex-col gap-2 sm:flex-row">
+        {canMove && (
+          <Button
+            className="h-11 flex-1 md:h-9"
+            disabled={pending}
+            onClick={onMove}
+          >
+            {pending ? "Moving…" : `Move it to ${to}`}
+          </Button>
+        )}
+        <Button
+          variant={canMove ? "outline" : "default"}
+          className="h-11 flex-1 md:h-9"
+          disabled={pending}
+          onClick={onOpen}
+        >
+          Start a session in it
+        </Button>
+      </div>
+      <button
+        type="button"
+        onClick={onBack}
+        className="text-primary min-h-11 px-1 text-sm md:min-h-8"
+      >
+        Pick another folder
+      </button>
+    </div>
+  );
+}

package/components/Projects/AddProject/NameForm.tsx

@@ -10,9 +10,11 @@ import { ParentPicker } from "./ParentPicker";
 // a separate, explicit click.
 export function NameForm({
   hostId,
+  workspaceId,
   onDone,
 }: {
   hostId: string;
+  workspaceId: string | null;
   onDone: (projectId: string) => void;
 }) {
   const [name, setName] = useState("");
@@ -67,7 +69,7 @@ export function NameForm({
       className="space-y-3"
       onSubmit={(e) => {
         e.preventDefault();
-        init.mutate({ hostId, parent, name: name.trim() });
+        init.mutate({ hostId, parent, name: name.trim(), workspaceId });
       }}
     >
       <Input

package/components/Projects/AddProject/WorkspacePick.tsx

@@ -0,0 +1,56 @@
+"use client";
+
+import { LayoutGrid } from "lucide-react";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { useWorkspacesQuery } from "@/data/workspaces";
+
+const NONE = "none";
+
+// "Adds to Internal Tools", changeable to another workspace or none.
+export function WorkspacePick({
+  workspaceId,
+  onChange,
+}: {
+  workspaceId: string | null;
+  onChange: (workspaceId: string | null) => void;
+}) {
+  const { data: workspaces = [] } = useWorkspacesQuery();
+  if (workspaces.length === 0) return null;
+  // One deleted since the dialog opened reads as none.
+  const value = workspaces.some((w) => w.id === workspaceId)
+    ? (workspaceId as string)
+    : NONE;
+  return (
+    <div className="flex items-center gap-2 text-sm">
+      <LayoutGrid className="text-muted-foreground h-3.5 w-3.5 shrink-0" />
+      <span className="text-muted-foreground shrink-0">Adds to</span>
+      <Select
+        value={value}
+        onValueChange={(v) => onChange(v === NONE ? null : v)}
+      >
+        <SelectTrigger
+          aria-label="Workspace"
+          className="h-11 min-w-0 flex-1 md:h-9"
+        >
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem value={NONE} className="min-h-11 md:min-h-0">
+            No workspace
+          </SelectItem>
+          {workspaces.map((w) => (
+            <SelectItem key={w.id} value={w.id} className="min-h-11 md:min-h-0">
+              {w.name}
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+    </div>
+  );
+}

package/components/Projects/AddProject/useAddExistingProject.ts

@@ -0,0 +1,58 @@
+"use client";
+
+import { FolderGit2, FolderPlus } from "lucide-react";
+import { toast } from "sonner";
+import type { Workspace } from "@/lib/db";
+import { useProjectsQuery } from "@/data/projects";
+import {
+  useMoveProjectToWorkspace,
+  useWorkspacesQuery,
+} from "@/data/workspaces";
+import { paletteActions } from "@/stores/palette";
+import { useAddProject } from "./useAddProject";
+
+// "Add existing project…": a searchable pick of the projects not in this
+// workspace, under the workspace each is in now; picking one moves it in.
+// A new one is the first choice.
+export function useAddExistingProject() {
+  const { data: projects = [] } = useProjectsQuery();
+  const { data: workspaces = [] } = useWorkspacesQuery();
+  const move = useMoveProjectToWorkspace();
+  const addProject = useAddProject();
+  return (workspace: Workspace) => {
+    const nameOf = (id: string | null) =>
+      workspaces.find((w) => w.id === id)?.name ?? "No workspace";
+    const others = projects
+      .filter((p) => !p.is_uncategorized && p.workspace_id !== workspace.id)
+      .sort(
+        (a, b) =>
+          nameOf(a.workspace_id).localeCompare(nameOf(b.workspace_id)) ||
+          a.name.localeCompare(b.name)
+      );
+    paletteActions.pick(`Add a project to ${workspace.name}…`, [
+      {
+        id: "add-existing.new",
+        title: "New project (folder, clone or name)…",
+        group: "",
+        icon: FolderPlus,
+        run: addProject,
+      },
+      ...others.map((p) => ({
+        id: `add-existing.${p.id}`,
+        title: p.name,
+        group: nameOf(p.workspace_id),
+        keywords: [p.working_directory],
+        icon: FolderGit2,
+        run: () =>
+          move.mutate(
+            { projectId: p.id, workspaceId: workspace.id },
+            {
+              onSuccess: () =>
+                toast.success(`${p.name} moved to ${workspace.name}`),
+              onError: (e) => toast.error(e.message),
+            }
+          ),
+      })),
+    ]);
+  };
+}

package/components/SessionList/WorkspaceSwitcher.tsx

@@ -7,6 +7,7 @@ import {
   ChevronDown,
   CircleCheck,
   Clock,
+  FolderPlus,
   Gauge,
   LayoutGrid,
   Pencil,
@@ -29,6 +30,7 @@ import { archivedUiActions, cleanupUiActions } from "@/stores/archivedUi";
 import { orchestratorOpenActions } from "@/stores/orchestratorOpen";
 import { sidebarUiActions } from "@/stores/sidebarUi";
 import { schedulesUiActions } from "@/stores/schedulesUi";
+import { useAddExistingProject } from "@/components/Projects/AddProject/useAddExistingProject";
 
 const icon = "mr-2 h-3.5 w-3.5";
 
@@ -44,6 +46,7 @@ export function WorkspaceSwitcher({
   const create = useCreateWorkspace();
   const update = useUpdateWorkspace();
   const remove = useDeleteWorkspace();
+  const addExisting = useAddExistingProject();
   const [dialog, setDialog] = useState<"new" | "rename" | null>(null);
   const name = current?.name ?? "All workspaces";
 
@@ -94,6 +97,13 @@ export function WorkspaceSwitcher({
           {current && (
             <>
               <DM.DropdownMenuSeparator />
+              <DM.DropdownMenuItem
+                onClick={() => addExisting(current)}
+                className="min-h-11 md:min-h-0"
+              >
+                <FolderPlus className={icon} />
+                Add existing project…
+              </DM.DropdownMenuItem>
               <DM.DropdownMenuItem
                 onClick={() => orchestratorOpenActions.request(current.id)}
               >

package/data/projects/add.ts

@@ -2,8 +2,26 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { CloneJob, FolderListing } from "@/lib/project-add";
 import { projectKeys } from "./keys";
 
+export interface ExistingProject {
+  id: string;
+  name: string;
+  workspaceId: string | null;
+}
+
+// A folder that's already a project: the add form offers to move it.
+export class ProjectExistsError extends Error {
+  constructor(
+    message: string,
+    readonly existing: ExistingProject
+  ) {
+    super(message);
+  }
+}
+
 async function json<T>(res: Response): Promise<T> {
   const data = await res.json();
+  if (res.status === 409 && data.existing)
+    throw new ProjectExistsError(data.error, data.existing);
   if (!res.ok) throw new Error(data.error || "Request failed");
   return data;
 }
@@ -28,13 +46,14 @@ export function useFolderListing(hostId: string, path: string) {
   });
 }
 
-// A project from a folder ({ path }) or a new one from a name.
+// A project from a folder ({ path }) or a new one from a name, in a
+// workspace when given. moveExisting moves the project already at { path }.
 export function useInitProject() {
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (
-      input: { hostId: string } & (
-        | { path: string }
+      input: { hostId: string; workspaceId: string | null } & (
+        | { path: string; moveExisting?: boolean }
         | { parent: string; name: string }
       )
     ) =>
@@ -54,6 +73,7 @@ export function useStartClone() {
       hostId: string;
       parent: string;
       url: string;
+      workspaceId: string | null;
     }) =>
       (await json<{ job: CloneJob }>(await post("/api/projects/clone", input)))
         .job,

package/lib/chat/driver.ts

@@ -35,8 +35,16 @@ export interface ChatStartOptions {
   // A fixed permission mode in place of the access setting, which then
   // can't be changed for this conversation.
   permissionMode?: PermissionMode;
+  // Checked before every tool call, whatever the permissions say: why it's
+  // refused, or null to let it go on to them.
+  toolGuard?: ToolGuard;
 }
 
+export type ToolGuard = (
+  tool: string,
+  input: Record<string, unknown>
+) => Promise<string | null>;
+
 // One live conversation with an agent. Messages sent while a turn runs are
 // queued by the provider and folded into the conversation.
 export interface UndoResult extends UndoPreview {