@saadnvd1/agent-os 0.3.700 → 0.3.723

package/app/api/sessions/[id]/analyst/route.ts

@@ -0,0 +1,11 @@
+import { sessionLinkView } from "@/lib/analyst";
+import { run } from "@/lib/analyst/route";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+// GET /api/sessions/:id/analyst - the live pairing this session is in, as
+// coder or analyst, or null.
+export async function GET(_request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return run(() => ({ link: sessionLinkView(id) }));
+}

package/app/api/sessions/[id]/crew/route.ts

@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { crewMembers } from "@/lib/sessions/crew";
+import { modelCatalog } from "@/lib/models/catalog";
+
+type RouteParams = { params: Promise<{ id: string }> };
+
+// GET /api/sessions/:id/crew - the session's role and the sessions it works
+// with (same crew), each with its model and whether that is local or cloud.
+export async function GET(_request: NextRequest, { params }: RouteParams) {
+  const { id } = await params;
+  const row = db
+    .prepare(`SELECT agent_role, crew_id FROM session_rows WHERE id = ?`)
+    .get(id) as
+    { agent_role: string | null; crew_id: string | null } | undefined;
+  if (!row)
+    return NextResponse.json({ error: "Session not found" }, { status: 404 });
+  const choices = new Map(modelCatalog().map((c) => [c.ref, c]));
+  const members = row.crew_id
+    ? crewMembers(row.crew_id).map((m) => {
+        const ref = m.model
+          ? `${m.agentType === "pi" ? "pi" : (m.modelProvider ?? "anthropic")}/${m.model}`
+          : null;
+        const choice = ref ? choices.get(ref) : undefined;
+        return {
+          ...m,
+          ref,
+          locality: choice?.locality ?? "cloud",
+          availability: choice?.availability.state ?? "unknown",
+        };
+      })
+    : [];
+  return NextResponse.json({
+    agentRole: row.agent_role,
+    crewId: row.crew_id,
+    members,
+  });
+}

package/app/api/sessions/[id]/export/estimate/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { parseExportRequest } from "@/lib/export/request";
+import { estimate } from "@/lib/export/service";
+import { readJson, refuseDemo, toResponse } from "@/lib/share/route";
+
+// POST /api/sessions/:id/export/estimate - what an export would hold: size,
+// tokens, the turns to pick from, and warnings. No file text.
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const refused = refuseDemo();
+  if (refused) return refused;
+  const read = await readJson(request);
+  if ("refused" in read) return read.refused;
+  try {
+    const { id } = await params;
+    const req = parseExportRequest(read.body);
+    return NextResponse.json(await estimate(id, req));
+  } catch (err) {
+    return toResponse(err);
+  }
+}

package/app/api/sessions/[id]/export/route.test.ts

@@ -0,0 +1,125 @@
+import { randomUUID } from "crypto";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { tempDir } from "@/lib/test-temp";
+
+process.env.AGENTOS_ARTIFACTS_DIR = tempDir("agentos-export-art-");
+const file = await import("./route");
+const estimate = await import("./estimate/route");
+const { saveItem } = await import("@/lib/chat/store");
+const { seedSession } = await import("@/lib/orchestrator/testing");
+const { createProject } = await import("@/lib/projects");
+
+const secret = ["gh", "p_", "c".repeat(36)].join("");
+const body = {
+  format: "md",
+  mode: "compact",
+  redact: "all",
+};
+
+const post = (b: unknown) =>
+  new Request("http://localhost/x", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(b),
+  });
+const params = (id: string) => ({ params: Promise.resolve({ id }) });
+
+function session(view: "chat" | "terminal" = "chat") {
+  const project = createProject({
+    name: `p-${randomUUID().slice(0, 6)}`,
+    workingDirectory: "/tmp/p",
+  });
+  const id = seedSession({ projectId: project.id, name: "Export me", view });
+  let t = 1;
+  const add = (i: Record<string, unknown>) =>
+    saveItem(id, { id: `x${t}`, createdAt: t++, ...i } as never);
+  add({ kind: "user", text: `key ${secret}` });
+  add({ kind: "assistant", text: "ok" });
+  add({ kind: "user", text: "second" });
+  add({ kind: "assistant", text: "done" });
+  return id;
+}
+
+afterEach(() => vi.unstubAllEnvs());
+
+describe("POST /api/sessions/:id/export", () => {
+  it("returns each format as a named download with size headers", async () => {
+    const id = session();
+    for (const [format, type, ext] of [
+      ["md", "text/markdown", "md"],
+      ["json", "application/json", "json"],
+      ["html", "text/html", "html"],
+    ]) {
+      const res = await file.POST(post({ ...body, format }), params(id));
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain(type);
+      expect(res.headers.get("content-disposition")).toBe(
+        `attachment; filename="export-me-all.${ext}"`
+      );
+      expect(res.headers.get("cache-control")).toBe("no-store");
+      const text = await res.text();
+      expect(Number(res.headers.get("x-export-bytes"))).toBe(
+        Buffer.byteLength(text)
+      );
+      expect(Number(res.headers.get("x-export-tokens"))).toBeGreaterThan(0);
+      expect(text).not.toContain(secret);
+    }
+  });
+
+  it("exports a range and names it", async () => {
+    const id = session();
+    const res = await file.POST(
+      post({ ...body, range: { from: 2, to: 2 } }),
+      params(id)
+    );
+    expect(res.headers.get("content-disposition")).toContain("-turn-2.md");
+    const text = await res.text();
+    expect(text).toContain("second");
+    expect(text).not.toContain("## Turn 1");
+  });
+
+  it("404s an unknown session and 400s a terminal one", async () => {
+    expect((await file.POST(post(body), params("nope"))).status).toBe(404);
+    const res = await file.POST(post(body), params(session("terminal")));
+    expect(res.status).toBe(400);
+  });
+
+  it("400s a bad format, mode, redaction or range", async () => {
+    const id = session();
+    for (const bad of [
+      { ...body, format: "pdf" },
+      { ...body, mode: "tiny" },
+      { ...body, redact: "none" },
+      { ...body, range: { from: 0, to: 2 } },
+      { ...body, range: { from: 9, to: 12 } },
+      { ...body, range: { last: -1 } },
+    ])
+      expect((await file.POST(post(bad), params(id))).status).toBe(400);
+  });
+
+  it("refuses in the demo", async () => {
+    vi.stubEnv("AGENTOS_DEMO", "1");
+    const res = await file.POST(post(body), params(session()));
+    expect(res.status).toBe(403);
+  });
+});
+
+describe("POST /api/sessions/:id/export/estimate", () => {
+  it("returns sizes, turns and warnings, and no body text", async () => {
+    const id = session();
+    const res = await estimate.POST(post(body), params(id));
+    expect(res.status).toBe(200);
+    const text = await res.text();
+    const j = JSON.parse(text);
+    expect(j.turns.map((t: { n: number }) => t.n)).toEqual([1, 2]);
+    expect(j.selected).toMatchObject({ from: 1, to: 2, of: 2, turns: 2 });
+    expect(j.estimate.compact.bytes).toBeGreaterThan(0);
+    expect(j.estimate.full.bytes).toBeGreaterThan(0);
+    expect(j.hits.secret).toBe(1);
+    expect(j.warnings.map((w: { code: string }) => w.code)).toContain(
+      "sensitive"
+    );
+    expect(text).not.toContain("done");
+    expect(text).not.toContain(secret);
+  });
+});

package/app/api/sessions/[id]/export/route.ts

@@ -0,0 +1,34 @@
+import { NextResponse } from "next/server";
+import { parseExportRequest } from "@/lib/export/request";
+import { buildFile } from "@/lib/export/service";
+import { TOO_BIG, exportFileName } from "@/lib/export/view";
+import { fail, readJson, refuseDemo, toResponse } from "@/lib/share/route";
+
+// POST /api/sessions/:id/export - the session (or a range of its turns) as a
+// Markdown, JSON or HTML file, redacted. Local work only.
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const refused = refuseDemo();
+  if (refused) return refused;
+  const read = await readJson(request);
+  if ("refused" in read) return read.refused;
+  try {
+    const { id } = await params;
+    const req = parseExportRequest(read.body);
+    const file = await buildFile(id, req);
+    if (file.tooBig) return fail(TOO_BIG, 413);
+    return new NextResponse(file.body, {
+      headers: {
+        "Content-Type": file.contentType,
+        "Content-Disposition": `attachment; filename="${exportFileName(file.title, file.slug, req.format)}"`,
+        "Cache-Control": "no-store",
+        "X-Export-Bytes": String(file.bytes),
+        "X-Export-Tokens": String(file.tokens),
+      },
+    });
+  } catch (err) {
+    return toResponse(err);
+  }
+}

package/app/api/sessions/[id]/fork/route.ts

@@ -1,3 +1,4 @@
+import { inheritGroup } from "@/lib/session-groups/assignSessions";
 import { NextRequest, NextResponse } from "next/server";
 import { randomUUID } from "crypto";
 import { getDb, queries, type Session, type Message } from "@/lib/db";
@@ -63,6 +64,8 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
         parent.host_id
       );
 
+    inheritGroup(parentId, newId);
+
     // NOTE: We do NOT copy claude_session_id here.
     // When the forked session is first attached, it will use --fork-session flag
     // with the parent's claude_session_id to create a new branched conversation.

package/app/api/sessions/[id]/group/route.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { assignSessions } from "@/lib/session-groups";
+import { groupRoute } from "@/lib/session-groups/route";
+
+const body = z.object({ groupId: z.string().nullable() });
+
+// POST /api/sessions/:id/group { groupId | null } - join a group of the
+// session's workspace, or leave.
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  return groupRoute(request, body, (b) => ({
+    ok: true,
+    ...assignSessions([id], b.groupId),
+  }));
+}

package/app/api/sessions/[id]/model/route.ts

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, type Session } from "@/lib/db";
+import { setChatModel } from "@/lib/chat/settings";
+import { providerFor, sessionRole } from "@/lib/models/resolve";
+import { switchSessionModel } from "@/lib/models/session-model";
+import { PI } from "@/lib/models/providers";
+import { formatModelRef, parseModelRef } from "@/lib/models/roles";
+
+// POST /api/sessions/:id/model {ref} - move a running session to another
+// model ("provider/model", or "pi/<provider>/<model>" for a Pi session),
+// keeping its conversation.
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const { ref } = (await request.json().catch(() => ({}))) as { ref?: unknown };
+  const session = db
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+    .get(id) as Session | undefined;
+  if (!session)
+    return NextResponse.json({ error: "Session not found" }, { status: 404 });
+  if (typeof ref !== "string" || !ref.trim())
+    return NextResponse.json({ error: "ref is required" }, { status: 400 });
+  try {
+    const parsed = parseModelRef(ref);
+    if (session.agent_type === "pi") {
+      if (parsed.provider !== PI)
+        throw new Error(
+          "A Pi session runs on a Pi model (pi/<provider>/<model>)"
+        );
+      await setChatModel(id, parsed.model);
+    } else {
+      if (parsed.provider === PI)
+        throw new Error("Only a Pi session can move to a Pi model");
+      await switchSessionModel(id, {
+        role: sessionRole(session),
+        ref: formatModelRef(parsed),
+        provider: providerFor(parsed.provider),
+        model: parsed.model,
+        source: "task",
+      });
+    }
+    return NextResponse.json({ ok: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/app/api/sessions/[id]/route.ts

@@ -19,6 +19,7 @@ import { statusDetector } from "@/lib/status-detector";
 import { deleteItems } from "@/lib/chat/store";
 import { clearQueue } from "@/lib/chat/queued";
 import { recordPreviousName } from "@/lib/session-names";
+import { getProject, moveSessionToProject } from "@/lib/projects";
 import { generateBranchName, getCurrentBranch, renameBranch } from "@/lib/git";
 import { runInBackground } from "@/lib/async-operations";
 import {
@@ -206,9 +207,15 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
       updates.push("system_prompt = ?");
       values.push(body.systemPrompt);
     }
-    if (body.groupPath !== undefined) {
-      updates.push("group_path = ?");
-      values.push(body.groupPath);
+
+    let clearedGroup: string | null = null;
+    if (typeof body.projectId === "string" && !existing.role) {
+      if (!getProject(body.projectId))
+        return NextResponse.json(
+          { error: "Project not found" },
+          { status: 404 }
+        );
+      clearedGroup = moveSessionToProject(id, body.projectId).clearedGroup;
     }
 
     if (updates.length > 0) {
@@ -221,7 +228,10 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
     }
 
     const session = queries.getSession(db).get(id) as Session;
-    return NextResponse.json({ session });
+    return NextResponse.json({
+      session,
+      ...(clearedGroup && { clearedGroup }),
+    });
   } catch (error) {
     console.error("Error updating session:", error);
     return NextResponse.json(

package/app/api/sessions/[id]/summarize/route.ts

@@ -1,3 +1,4 @@
+import { inheritGroup } from "@/lib/session-groups/assignSessions";
 import { effectiveAutoApprove } from "@/lib/approvals/no-approvals";
 import { routedRun } from "@/lib/models/launch";
 import { NextRequest, NextResponse } from "next/server";
@@ -305,6 +306,7 @@ export async function POST(
         session.host_id
       );
 
+      inheritGroup(session.id, newId);
       newSession = queries.getSession(db).get(newId) as Session;
       const newTmuxSession = tmuxName;
 

package/app/api/sessions/claims.test.ts

@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { seedSession, seedWorkspace } from "@/lib/orchestrator/testing";
+
+const { db } = await import("@/lib/db");
+const { machineId } = await import("@/lib/claims/machine");
+const { upsertLocal, upsertRemote } = await import("@/lib/claims/store");
+const { refreshOverlapCache, resetOverlapCache } =
+  await import("@/lib/claims/overlapCache");
+const { GET } = await import("./route");
+
+const REPO = "git.example.test/team/widgets";
+
+beforeEach(() => {
+  db.prepare(`DELETE FROM work_claims`).run();
+  resetOverlapCache();
+});
+
+function localClaim(sessionId: string, files: string[]) {
+  upsertLocal(
+    { id: machineId(), name: "here" },
+    {
+      sessionId,
+      sessionName: "Tidy auth",
+      repo: REPO,
+      branch: "feature/tidy",
+      base: "main",
+      goal: "Tidy auth",
+      files,
+      filesMore: 0,
+      prUrl: null,
+    }
+  );
+}
+
+const remote = (id: string, files: string[], branch = "feature/login") =>
+  upsertRemote(machineId(), "peer-1", {
+    id,
+    origin: "box-machine",
+    origin_name: "box",
+    hops: 0,
+    source: "session",
+    session_name: "Rework login sessions",
+    repo: REPO,
+    branch,
+    base: "main",
+    goal: "Rework login sessions",
+    files,
+    files_more: 0,
+    pr_url: null,
+    ttl_s: 600,
+    age_s: 60,
+    released: null,
+  });
+
+const FILES = ["a/one.ts", "a/two.ts", "a/three.ts"];
+
+const rows = async () => {
+  const body = await (await GET()).json();
+  return body as {
+    sessions: { id: string; overlap?: Record<string, unknown> | null }[];
+    claims: { id: string; fileCount: number; files?: string[] }[];
+    claimOverlaps: { a: string; b: string; strength: string }[];
+  };
+};
+
+describe("GET /api/sessions with claims", () => {
+  it("puts a strong overlap on the session that has it, and no other", async () => {
+    const t = seedWorkspace();
+    const mine = seedSession({ projectId: t.app.id, name: "Tidy auth" });
+    const other = seedSession({ projectId: t.app.id, name: "Unrelated" });
+    localClaim(mine, FILES);
+    remote("claim-box-1", FILES);
+    refreshOverlapCache();
+    const body = await rows();
+    expect(body.sessions.find((s) => s.id === mine)?.overlap).toEqual({
+      strength: "strong",
+      machine: "box",
+      goal: "Rework login sessions",
+      shared: 3,
+      claimId: "claim-box-1",
+      mineId: `s-${mine}`,
+    });
+    expect(body.sessions.find((s) => s.id === other)?.overlap).toBeUndefined();
+  });
+
+  it("marks a small file overlap weak", async () => {
+    const t = seedWorkspace();
+    const mine = seedSession({ projectId: t.app.id, name: "Tidy auth" });
+    localClaim(mine, ["a/1.ts", "a/2.ts", "a/3.ts", "a/4.ts", "a/5.ts"]);
+    remote(
+      "claim-box-2",
+      ["a/1.ts", "a/2.ts", "b/1.ts", "b/2.ts", "b/3.ts"],
+      "feature/other"
+    );
+    refreshOverlapCache();
+    const row = (await rows()).sessions.find((s) => s.id === mine);
+    expect(row?.overlap?.strength).toBe("weak");
+  });
+
+  it("lists claims without their paths, and the overlapping pairs", async () => {
+    const t = seedWorkspace();
+    const mine = seedSession({ projectId: t.app.id, name: "Tidy auth" });
+    localClaim(mine, FILES);
+    remote("claim-box-1", FILES);
+    refreshOverlapCache();
+    const body = await rows();
+    expect(body.claims.map((c) => c.id).sort()).toEqual(
+      [`s-${mine}`, "claim-box-1"].sort()
+    );
+    expect(body.claims.every((c) => c.fileCount === 3 && !c.files)).toBe(true);
+    expect(body.claimOverlaps).toHaveLength(1);
+    expect(body.claimOverlaps[0].strength).toBe("strong");
+  });
+
+  it("serves no claims before the loop has run", async () => {
+    const t = seedWorkspace();
+    seedSession({ projectId: t.app.id, name: "Tidy auth" });
+    const body = await rows();
+    expect(body.claims).toEqual([]);
+    expect(body.sessions.every((s) => !s.overlap)).toBe(true);
+  });
+});

package/app/api/sessions/group/route.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { assignSessions } from "@/lib/session-groups";
+import { groupRoute } from "@/lib/session-groups/route";
+
+const body = z.object({
+  ids: z.array(z.string()).min(1).max(200),
+  groupId: z.string().nullable(),
+});
+
+// POST /api/sessions/group { ids, groupId | null } - the multi-select move.
+// All or none: one session of another workspace refuses the lot.
+export async function POST(request: Request) {
+  return groupRoute(request, body, (b) => ({
+    ok: true,
+    ...assignSessions(b.ids, b.groupId),
+  }));
+}

package/app/api/sessions/route.ts

@@ -1,13 +1,17 @@
 import { NextRequest, NextResponse } from "next/server";
-import { getDb, queries, type Session, type Group } from "@/lib/db";
+import { getDb, queries, type Session } from "@/lib/db";
+import { listGroups } from "@/lib/session-groups";
 import { isValidAgentType } from "@/lib/providers";
 import { clientSend } from "@/lib/chat/client-send";
 import { CHAT_ACCESS } from "@/lib/chat/events";
 import { launchSession } from "@/lib/sessions/launch";
+import { isAgentRole } from "@/lib/models/agent-roles";
+import { ModelUnavailableError } from "@/lib/models/agent-binding";
 import { namesLine, waitBadges } from "@/lib/bus/waits/store";
+import { claimsSnapshot } from "@/lib/claims";
 import { isProjectRef } from "@/lib/tasks/project-ref";
 
-// GET /api/sessions - List all sessions and groups
+// GET /api/sessions - List the sidebar's sessions and the user's groups
 export async function GET() {
   try {
     const db = getDb();
@@ -15,12 +19,15 @@ export async function GET() {
     // tasks live in the Tasks panel, a moved one on the machine it moved to,
     // and archived sessions in the Archived view: none is in the sidebar.
     const badges = waitBadges();
+    const claims = claimsSnapshot();
     const sessions = (queries.getSidebarSessions(db).all() as Session[]).map(
       (s) => {
         const b = badges.get(s.id);
+        const overlap = claims.bySession.get(s.id);
+        const row = overlap ? { ...s, overlap } : s;
         return b
           ? {
-              ...s,
+              ...row,
               waiting_on: b.on.length
                 ? namesLine(b.on.map((w) => w.name))
                 : null,
@@ -28,18 +35,15 @@ export async function GET() {
                 ? namesLine(b.by.map((w) => w.name))
                 : null,
             }
-          : s;
+          : row;
       }
     );
-    const groups = queries.getAllGroups(db).all() as Group[];
-
-    // Convert expanded from 0/1 to boolean
-    const formattedGroups = groups.map((g) => ({
-      ...g,
-      expanded: Boolean(g.expanded),
-    }));
-
-    return NextResponse.json({ sessions, groups: formattedGroups });
+    return NextResponse.json({
+      sessions,
+      sessionGroups: listGroups(),
+      claims: claims.claims,
+      claimOverlaps: claims.overlaps,
+    });
   } catch (error) {
     console.error("Error fetching sessions:", error);
     return NextResponse.json(
@@ -95,8 +99,10 @@ export async function POST(request: NextRequest) {
       name: str(body.name),
       view: body.view === "terminal" ? "terminal" : undefined,
       parentSessionId: str(body.parentSessionId),
-      groupPath: str(body.groupPath) ?? undefined,
       systemPrompt: str(body.systemPrompt),
+      agentRole: isAgentRole(body.agentRole) ? body.agentRole : null,
+      crewId: str(body.crewId),
+      useFallback: body.onUnavailable === "fallback",
     });
     const db = getDb();
     const claudeSessionId = repeat ? null : str(body.claudeSessionId);
@@ -129,6 +135,17 @@ export async function POST(request: NextRequest) {
       { status: 201 }
     );
   } catch (error) {
+    if (error instanceof ModelUnavailableError)
+      return NextResponse.json(
+        {
+          code: error.code,
+          role: error.role,
+          ref: error.ref,
+          fallback: error.fallback ?? null,
+          error: error.message,
+        },
+        { status: 409 }
+      );
     const message = error instanceof Error ? error.message : String(error);
     console.error("Error creating session:", message);
     return NextResponse.json({ error: message }, { status: 400 });

package/app/page.tsx

@@ -122,6 +122,10 @@ const LumifyHubDialogs = dynamic(
     ),
   { ssr: false }
 );
+const ClaimsSheet = dynamic(
+  () => import("@/components/Claims/ClaimsSheet").then((m) => m.ClaimsSheet),
+  { ssr: false }
+);
 const UsageDialog = dynamic(
   () => import("@/components/Usage/UsageDialog").then((m) => m.UsageDialog),
   { ssr: false }
@@ -134,6 +138,10 @@ const ShareDialog = dynamic(
   () => import("@/components/Share/ShareDialog").then((m) => m.ShareDialog),
   { ssr: false }
 );
+const ExportSheet = dynamic(
+  () => import("@/components/Export/ExportSheet").then((m) => m.ExportSheet),
+  { ssr: false }
+);
 const CommandPalette = dynamic(
   () =>
     import("@/components/CommandPalette/CommandPalette").then(
@@ -159,8 +167,10 @@ const AppDialogs = memo(function AppDialogs({
       <CleanupDialog />
       <LumifyHubDialogs />
       <UsageDialog />
+      <ClaimsSheet />
       <MoveDialog />
       <ShareDialog />
+      <ExportSheet />
       <AwayReport />
       <IncomingLinks />
       <CommandPalette />