@saadnvd1/agent-os 0.3.460 → 0.3.462

package/README.md

@@ -494,13 +494,29 @@ root. Every field is optional:
   "browse": { "login": "/dev/login", "map": "docs/browsing.md" },
   "database": { "from": "app_development", "env": "DATABASE_NAME" },
   "notes": ["Kill your own server by port: lsof -ti tcp:$RAILS_PORT"],
-  "merge": { "method": "squash" }
+  "merge": { "method": "squash" },
+  "deploy": {
+    "deployed": "~/.deploy/deployed",
+    "health": "https://app.example.com/up"
+  }
 }
 ```
 
 `merge` sets the project's merge method and branch clean-up (see
 [Merging settings](#tasks)).
 
+`deploy` is how [Away mode](#orchestrator) checks a merge went live: `deployed`
+is a file your deploy writes the deployed commit to, `failed` (optional) one it
+writes a commit whose deploy failed to, and `health` (optional) a URL that
+answers 2xx once the server is back (a path alone is this AgentOS server's own,
+as this repository's `agentos.json` uses with `scripts/autodeploy`'s state
+files). A merge counts as deployed once the `deployed` commit contains it and
+`health` answers; as failed when the `failed` commit contains it, the server
+doesn't come back within 3 minutes (or, when its health answer has a
+`startedAt`, hasn't restarted since the merge), or it isn't deployed `within_minutes`
+(30) after the merge. No `deployed` file on the machine means nothing deploys
+there, and nothing is checked.
+
 Every task and worktree session takes a **port slot**, and each named port is
 `base + slot` (a project with no `ports` still gets a `PORT` from 3100), so
 parallel sessions never share a dev server port. The slot is kept on the
@@ -1007,6 +1023,30 @@ reset` yourself in a terminal on the machine: it refuses inside an
   the same line carries Pause/Resume. While paused it acts on nothing:
   events queue, acting tools refuse, and its stack starts and lands hold.
   It can still read, note and ask. Resume delivers what queued, folded.
+- **Away mode:** turn it on when you step away, from the coffee cup in the
+  sidebar header or ⌘K ("Away for 4 hours"), for 1 hour, 4 hours, until
+  morning (8 AM) or until you're back. It's kept in `away_periods` (who set
+  it, when, when it ends), the cup turns amber while it's on (with an amber dot on the phone's menu button), and it
+  ends on its own at its time. Every orchestrator gets an event, and a line
+  leading its digest, saying you're away and to follow work through rather
+  than only react. Every 10 minutes a sweep, written as code with no model
+  scanning, acts on what it finds and logs each step in the orchestrator's
+  chat: a task quiet 30 minutes with no PR (or failing CI) is nudged, at most
+  twice; an idle task with uncommitted work and no PR is asked to commit and
+  open one or say why not; a PR green and settled whose review never started
+  or was lost has it run again (once seen on two sweeps, so the orchestrator
+  had its turn); and after each merge, the project's `deploy` check says
+  whether it went live and the server came back, with a failure sent to the
+  orchestrator as an event. Interactive sessions are yours: one with
+  uncommitted work is asked once to wrap up, and nothing more. Paused
+  workspaces aren't swept. Hard lines still become asks, and while you're
+  away the asks raised, failed deploys and any `aos notify` an orchestrator
+  sends reach your phone as one message per sweep. Turning it off (or its running out) builds "While you were
+  away" from the database: what merged and deployed with PR links, what's
+  still in flight and which gate or blocker holds it, what failed, was dropped
+  or was escalated, and what waits on you (an explicit "none"). It opens on
+  whichever device is open until you dismiss it, a short summary goes to
+  your phone, and the report stays in Settings → Audits (`away/`).
 
 ## LumifyHub (optional)
 
@@ -1222,8 +1262,16 @@ descriptors, child processes and spawns per minute; `scripts/perf/execs.mjs
 spawns with eslogger (macOS) or strace (Linux) and need passwordless sudo for
 that one number. Run them on a machine with room to spare.
 
-A pre-commit hook formats and lints staged files, then typechecks and runs the
-tests. CI runs `scripts/check --build` on every pull request and push to main,
+A pre-commit hook (`.husky/pre-commit`, installed by `npm install`) checks
+only what is staged, in well under two seconds: `prettier --check`, failing
+with the `npx prettier --write …` command that fixes it, and a scan of the
+added lines for token-shaped secrets with the merge gate's own rule
+(`scripts/hooks/staged-secrets.ts` reads `secretsIn` from
+`lib/orchestrator/diff.ts`), naming the file and line. Build a test's fake
+token at runtime (`"gh" + "p_" + "a".repeat(36)`) rather than writing it
+whole. It runs in the worktrees AgentOS makes too, which have no `.husky/_`
+until `npm install` runs in them. Typecheck, lint and tests are left to CI.
+In an emergency, `git commit --no-verify` skips it. CI runs `scripts/check --build` on every pull request and push to main,
 which also holds the app's first-load JavaScript to a budget
 (`scripts/check-bundle.mjs`; `npx next experimental-analyze` shows what's in
 it), and fails a pull request whose body has no Code review section for its head

package/app/api/away/route.ts

@@ -0,0 +1,56 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import { getDevice } from "@/lib/security/devices";
+import { turnAwayOff, turnAwayOn } from "@/lib/away/run";
+import { awayView } from "@/lib/away/view";
+
+// GET /api/away - whether Saad is away, and the report he hasn't dismissed.
+export function GET() {
+  return NextResponse.json(awayView());
+}
+
+// POST /api/away - { on: true, expiresAt: ISO | null } turns Away on (or
+// moves its end); { on: false } turns it off and builds the report. From a
+// trusted place, as Pause is: it changes what the orchestrators do.
+export async function POST(request: NextRequest) {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  const body = (await request.json().catch(() => ({}))) as {
+    on?: unknown;
+    expiresAt?: unknown;
+  };
+  if (typeof body.on !== "boolean")
+    return NextResponse.json(
+      { error: "on must be true or false" },
+      { status: 400 }
+    );
+  if (!body.on) {
+    turnAwayOff("saad");
+    return NextResponse.json(awayView());
+  }
+  let expiresAt: number | null = null;
+  if (body.expiresAt !== null && body.expiresAt !== undefined) {
+    expiresAt =
+      typeof body.expiresAt === "string" ? Date.parse(body.expiresAt) : NaN;
+    if (!Number.isFinite(expiresAt))
+      return NextResponse.json(
+        { error: "expiresAt must be a time or null" },
+        { status: 400 }
+      );
+  }
+  const { approver } = gate;
+  const setBy = approver.deviceId
+    ? (getDevice(approver.deviceId)?.name ?? "a device")
+    : approver.via === "loopback"
+      ? "this machine"
+      : "the tailnet";
+  try {
+    turnAwayOn({ setBy, expiresAt });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 400 }
+    );
+  }
+  return NextResponse.json(awayView());
+}

package/app/api/away/seen/route.ts

@@ -0,0 +1,12 @@
+import { NextRequest, NextResponse } from "next/server";
+import { markReportSeen } from "@/lib/away/state";
+
+// POST /api/away/seen - { id }: dismiss that "While you were away" report.
+// It stays in Settings > Audits.
+export async function POST(request: NextRequest) {
+  const { id } = (await request.json().catch(() => ({}))) as { id?: unknown };
+  if (typeof id !== "number" || !Number.isInteger(id))
+    return NextResponse.json({ error: "id must be a number" }, { status: 400 });
+  markReportSeen(id);
+  return NextResponse.json({ ok: true });
+}

package/app/api/health/route.ts

@@ -0,0 +1,9 @@
+import { NextResponse } from "next/server";
+
+const startedAt = new Date(Date.now() - process.uptime() * 1000).toISOString();
+
+// GET /api/health - the server is up and answering; when it started, so a
+// deploy check can tell it restarted after a merge (lib/away/deploy.ts).
+export function GET() {
+  return NextResponse.json({ ok: true, startedAt });
+}

package/app/page.tsx

@@ -32,6 +32,7 @@ if (typeof window !== "undefined") {
 }
 import { PaneProvider, usePanes } from "@/contexts/PaneContext";
 import { Pane } from "@/components/Pane";
+import { AwayReport } from "@/components/Away/AwayReport";
 import { useNotifications } from "@/hooks/useNotifications";
 import { useViewport } from "@/hooks/useViewport";
 import { useViewportHeight } from "@/hooks/useViewportHeight";
@@ -128,6 +129,7 @@ const AppDialogs = memo(function AppDialogs() {
       <LumifyHubDialogs />
       <UsageDialog />
       <MoveDialog />
+      <AwayReport />
       <CommandPalette />
     </>
   );

package/components/Away/AwayReport.tsx

@@ -0,0 +1,16 @@
+"use client";
+
+import dynamic from "next/dynamic";
+import { useAwayQuery } from "@/data/away";
+
+const AwayReportDialog = dynamic(
+  () => import("./AwayReportDialog").then((m) => m.AwayReportDialog),
+  { ssr: false }
+);
+
+// Opens "While you were away" when Away has ended and its report hasn't
+// been dismissed, on whichever device is open.
+export function AwayReport() {
+  const { data } = useAwayQuery();
+  return data?.report ? <AwayReportDialog report={data.report} /> : null;
+}

package/components/Away/AwayReportDialog.tsx

@@ -0,0 +1,193 @@
+"use client";
+
+import type { ReactNode } from "react";
+import { ExternalLink } from "lucide-react";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import type {
+  AwayReport,
+  DeployState,
+  WorkspaceReport,
+} from "@/lib/away/report";
+import { useDismissAwayReport } from "@/data/away";
+import { settingsUiActions } from "@/stores/settingsUi";
+import { cn } from "@/lib/utils";
+import { awayRange } from "./time";
+
+const DEPLOY: Record<DeployState, { label: string; tone: string }> = {
+  deployed: {
+    label: "Deployed",
+    tone: "text-emerald-700 dark:text-emerald-400",
+  },
+  failed: { label: "Deploy failed", tone: "text-destructive" },
+  pending: {
+    label: "Deploy not confirmed",
+    tone: "text-amber-700 dark:text-amber-300",
+  },
+  unchecked: { label: "No deploy check", tone: "text-muted-foreground" },
+};
+
+function PrLink({ pr, url }: { pr: number | null; url: string | null }) {
+  if (!pr) return null;
+  if (!url || !url.startsWith("https://"))
+    return <span className="text-muted-foreground">#{pr}</span>;
+  return (
+    <a
+      href={url}
+      target="_blank"
+      rel="noreferrer"
+      className="text-primary inline-flex min-h-11 items-center gap-1 underline-offset-2 hover:underline md:min-h-0"
+    >
+      #{pr}
+      <ExternalLink className="h-3 w-3" />
+    </a>
+  );
+}
+
+function Row({ children }: { children: ReactNode }) {
+  return (
+    <li className="bg-foreground/[0.03] rounded-xl px-3 py-2 text-sm break-words">
+      {children}
+    </li>
+  );
+}
+
+function Section<T>({
+  title,
+  report,
+  pick,
+  render,
+  empty,
+}: {
+  title: string;
+  report: AwayReport;
+  pick: (w: WorkspaceReport) => T[];
+  render: (item: T) => ReactNode;
+  empty: string;
+}) {
+  const groups = report.workspaces.filter((w) => pick(w).length);
+  const many = report.workspaces.length > 1;
+  return (
+    <section className="space-y-1.5">
+      <h3 className="label-mono text-muted-foreground">{title}</h3>
+      {groups.length ? (
+        <ul className="space-y-1.5">
+          {groups.flatMap((w) =>
+            pick(w).map((item, i) => (
+              <Row key={`${w.id}-${i}`}>
+                {many && (
+                  <span className="text-muted-foreground mr-1.5 text-xs">
+                    {w.name}
+                  </span>
+                )}
+                {render(item)}
+              </Row>
+            ))
+          )}
+        </ul>
+      ) : (
+        <p className="text-muted-foreground px-1 text-sm">{empty}</p>
+      )}
+    </section>
+  );
+}
+
+export function AwayReportDialog({ report }: { report: AwayReport }) {
+  const dismiss = useDismissAwayReport();
+  const close = () => dismiss.mutate(report.awayId);
+  const t = report.totals;
+  return (
+    <Dialog open onOpenChange={(open) => !open && close()}>
+      <DialogContent className="max-h-[90vh] max-w-lg overflow-y-auto [&>*]:min-w-0">
+        <DialogHeader>
+          <DialogTitle>While you were away</DialogTitle>
+          <DialogDescription>
+            {awayRange(report.startedAt, report.endedAt)}
+            {report.endedBy === "expired" ? ", when Away ran out" : ""}.{" "}
+            {t.merged} merged, {t.inFlight} in flight, {t.failed} failed or
+            escalated, {t.waiting} waiting on you.
+          </DialogDescription>
+        </DialogHeader>
+        <div className="space-y-4">
+          <Section
+            title="Waiting on you"
+            report={report}
+            pick={(w) => w.waiting}
+            empty="None. Nothing is waiting on you."
+            render={(a) => (
+              <>
+                {a.hardLine && (
+                  <span className="text-destructive mr-1.5 text-xs font-medium">
+                    Hard line
+                  </span>
+                )}
+                <span className="text-muted-foreground mr-1">{a.kind}:</span>
+                {a.title}
+              </>
+            )}
+          />
+          <Section
+            title="Merged"
+            report={report}
+            pick={(w) => w.merged}
+            empty="None."
+            render={(m) => (
+              <>
+                <span className="font-medium">{m.task}</span>{" "}
+                <PrLink pr={m.pr} url={m.url} />
+                <span className={cn("block text-xs", DEPLOY[m.deploy].tone)}>
+                  {DEPLOY[m.deploy].label}
+                  {m.deployDetail ? `: ${m.deployDetail}` : ""}
+                </span>
+              </>
+            )}
+          />
+          <Section
+            title="Still in flight"
+            report={report}
+            pick={(w) => w.inFlight}
+            empty="None."
+            render={(f) => (
+              <>
+                <span className="font-medium">{f.task}</span>{" "}
+                <PrLink pr={f.pr} url={f.url} />
+                <span className="text-muted-foreground block text-xs">
+                  {f.why}
+                </span>
+              </>
+            )}
+          />
+          <Section
+            title="Failed or escalated"
+            report={report}
+            pick={(w) => w.failed}
+            empty="None."
+            render={(f) => f.what}
+          />
+        </div>
+        <DialogFooter className="gap-2">
+          <Button
+            variant="secondary"
+            className="h-11 md:h-9"
+            onClick={() => {
+              close();
+              settingsUiActions.open("audits");
+            }}
+          >
+            Kept in Audits
+          </Button>
+          <Button className="h-11 md:h-9" onClick={close}>
+            Done
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

package/components/Away/AwayToggle.tsx

@@ -0,0 +1,91 @@
+"use client";
+
+import { Coffee, Undo2 } from "lucide-react";
+import { toast } from "sonner";
+import {
+  ADropdownMenu,
+  menuItem,
+  separator,
+} from "@/components/a/ADropdownMenu";
+import { Button } from "@/components/ui/button";
+import {
+  AWAY_DURATIONS,
+  awayEnds,
+  useAwayQuery,
+  useSetAway,
+  type AwayDuration,
+} from "@/data/away";
+import { cn } from "@/lib/utils";
+import { awayUntil } from "./time";
+
+// The sidebar header's Away switch: off, a coffee cup that offers how
+// long; on, the same cup in amber, whose menu says until when and turns
+// it off.
+export function AwayToggle() {
+  const { data } = useAwayQuery();
+  const setAway = useSetAway();
+  const away = data?.away ?? null;
+  const choose = (d: AwayDuration) =>
+    setAway.mutate(
+      { expiresAt: awayEnds(d) },
+      { onError: (e) => toast.error(e.message) }
+    );
+  const durations = AWAY_DURATIONS.map((d) =>
+    menuItem(away ? d.label.replace(/^For/, "Change to") : d.label, () =>
+      choose(d.id)
+    )
+  );
+  const until = away ? awayUntil(away.expiresAt) : "";
+  return (
+    <ADropdownMenu
+      minWidth="220px"
+      trigger={
+        <Button
+          variant="ghost"
+          size="icon-sm"
+          aria-label={away ? `Away ${until}` : "Away"}
+          title={
+            away
+              ? `Away ${until}`
+              : "Away: let the orchestrators follow work through"
+          }
+          disabled={setAway.isPending}
+          className={cn(
+            "relative h-11 w-11 md:h-8 md:w-8",
+            away &&
+              "bg-amber-500/20 text-amber-700 ring-1 ring-amber-500/50 hover:bg-amber-500/30 dark:text-amber-300"
+          )}
+        >
+          <Coffee className="h-4 w-4" />
+        </Button>
+      }
+      items={
+        away
+          ? [
+              menuItem(
+                "I'm back",
+                () =>
+                  setAway.mutate(false, {
+                    onError: (e) => toast.error(e.message),
+                  }),
+                {
+                  icon: Undo2,
+                  description: `Away ${until}. Turning it off shows what happened.`,
+                }
+              ),
+              separator(),
+              ...durations,
+            ]
+          : [
+              menuItem("Away", () => {}, {
+                disabled: true,
+                description:
+                  "Orchestrators follow work through; asks reach your phone in batches.",
+              }),
+              separator(),
+              ...durations,
+            ]
+      }
+    />
+  );
+}

package/components/Away/time.test.ts

@@ -0,0 +1,20 @@
+import { afterAll, describe, expect, it } from "vitest";
+import { awayRange } from "./time";
+
+// A zone that isn't UTC, so reading UTC as local would show.
+const zone = process.env.TZ;
+process.env.TZ = "America/Chicago";
+afterAll(() => {
+  process.env.TZ = zone;
+});
+
+describe("the report's time range", () => {
+  it("reads SQLite's UTC times as UTC, not local", () => {
+    expect(
+      awayRange("2026-10-11 03:01:00", "2026-10-11 05:30:00", "en-US")
+    ).toMatch(/^Sat 10:01\sPM to Sun 12:30\sAM$/);
+    expect(
+      awayRange("2026-10-11 15:00:00", "2026-10-11 17:30:00", "en-US")
+    ).toMatch(/^10:00\sAM to 12:30\sPM$/);
+  });
+});

package/components/Away/time.ts

@@ -0,0 +1,32 @@
+// `locale` undefined: the browser's own.
+const clock = (d: Date, locale?: string) =>
+  d.toLocaleTimeString(locale, { hour: "numeric", minute: "2-digit" });
+
+// "until 4:30 PM", "until Sat 8:00 AM", or "until you're back".
+export function awayUntil(expiresAt: string | null, now = new Date()): string {
+  if (!expiresAt) return "until you're back";
+  const d = new Date(expiresAt);
+  const day =
+    d.toDateString() === now.toDateString()
+      ? ""
+      : `${d.toLocaleDateString(undefined, { weekday: "short" })} `;
+  return `until ${day}${clock(d)}`;
+}
+
+// The report's times are SQLite's UTC "YYYY-MM-DD HH:MM:SS".
+const utc = (t: string) =>
+  new Date(/[zZ]|[+-]\d\d:?\d\d$/.test(t) ? t : `${t.replace(" ", "T")}Z`);
+
+export function awayRange(
+  startedAt: string,
+  endedAt: string,
+  locale?: string
+): string {
+  const a = utc(startedAt);
+  const b = utc(endedAt);
+  const sameDay = a.toDateString() === b.toDateString();
+  const day = (d: Date) => d.toLocaleDateString(locale, { weekday: "short" });
+  return sameDay
+    ? `${clock(a, locale)} to ${clock(b, locale)}`
+    : `${day(a)} ${clock(a, locale)} to ${day(b)} ${clock(b, locale)}`;
+}

package/components/Away/useAwayCommands.ts

@@ -0,0 +1,43 @@
+"use client";
+
+import { Coffee, Undo2 } from "lucide-react";
+import { toast } from "sonner";
+import type { PaletteCommand } from "@/lib/palette/registry";
+import { usePaletteCommands } from "@/hooks/usePaletteCommands";
+import {
+  AWAY_DURATIONS,
+  awayEnds,
+  useAwayQuery,
+  useSetAway,
+} from "@/data/away";
+
+// ⌘K: "Away for 4 hours", "I'm back", and the rest of the toggle's menu.
+export function useAwayCommands(): void {
+  const { data } = useAwayQuery();
+  const setAway = useSetAway();
+  const on = !!data?.away;
+  const onError = (e: Error) => toast.error(e.message);
+  const commands: PaletteCommand[] = [
+    ...(on
+      ? [
+          {
+            id: "away.off",
+            title: "I'm back (turn Away off)",
+            group: "Away",
+            keywords: ["away", "back", "return"],
+            icon: Undo2,
+            run: () => setAway.mutate(false, { onError }),
+          },
+        ]
+      : []),
+    ...AWAY_DURATIONS.map((d) => ({
+      id: `away.${d.id}`,
+      title: `${on ? "Stay away" : "Away"} ${d.label.replace(/^For/, "for").replace(/^Until/, "until")}`,
+      group: "Away",
+      keywords: ["away", "afk", "step away", "leave"],
+      icon: Coffee,
+      run: () => setAway.mutate({ expiresAt: awayEnds(d.id) }, { onError }),
+    })),
+  ];
+  usePaletteCommands("away", commands);
+}

package/components/Chat/Messages.tsx

@@ -159,6 +159,7 @@ const NOTE_LABEL = {
   escalation: "Saad decides",
   ask: "Ask",
   pause: "Pause",
+  away: "Away",
 } as const;
 
 export function NoteLine({ item }: { item: Of<"note"> }) {

package/components/CommandPalette/useAppCommands.ts

@@ -32,6 +32,7 @@ import { useAddProject } from "@/components/Projects/AddProject/useAddProject";
 import { usageUiActions } from "@/stores/usageUi";
 import { settingsCommands } from "@/components/Settings/commands";
 import { DRAFT_KEYS } from "@/lib/drafts";
+import { useAwayCommands } from "@/components/Away/useAwayCommands";
 
 const LAST_THEME = "agentOS-last-theme-";
 
@@ -181,6 +182,7 @@ export function useAppCommands({
       })),
   ];
   usePaletteCommands("app", app);
+  useAwayCommands();
 
   usePaletteCommands(
     "sessions",

package/components/Pane/MobileTabBar.tsx

@@ -27,6 +27,8 @@ import {
   Users,
 } from "lucide-react";
 import { cn } from "@/lib/utils";
+import { useAwayQuery } from "@/data/away";
+import { awayUntil } from "@/components/Away/time";
 import type { Session, Project } from "@/lib/db";
 import type { LucideIcon } from "lucide-react";
 import { HostBadge } from "@/components/Hosts/HostBadge";
@@ -98,6 +100,7 @@ export function MobileTabBar({
   onSelectSession,
   onFind,
 }: MobileTabBarProps) {
+  const away = useAwayQuery().data?.away ?? null;
   // Find current session index and calculate prev/next
   const currentIndex = session
     ? sessions.findIndex((s) => s.id === session.id)
@@ -164,9 +167,19 @@ export function MobileTabBar({
             e.stopPropagation();
             onMenuClick();
           }}
-          className="h-8 w-8 shrink-0"
+          aria-label={
+            away ? `Menu (Away ${awayUntil(away.expiresAt)})` : "Menu"
+          }
+          className="relative h-8 w-8 shrink-0 after:absolute after:-inset-1.5 after:content-['']"
         >
           <Menu className="h-4 w-4" />
+          {/* The sidebar's amber cup is out of sight here: Away still shows. */}
+          {away && (
+            <span
+              aria-hidden
+              className="absolute top-1 right-1 h-2 w-2 rounded-full bg-amber-500"
+            />
+          )}
         </Button>
       )}
 

package/components/SessionList/SidebarHeader.tsx

@@ -35,6 +35,7 @@ import { settingsUiActions } from "@/stores/settingsUi";
 import { usageUiActions } from "@/stores/usageUi";
 import { WorkspaceSwitcher } from "./WorkspaceSwitcher";
 import { LoadGauge } from "./LoadGauge";
+import { AwayToggle } from "@/components/Away/AwayToggle";
 import { useSchedulesGlance } from "./useSchedulesGlance";
 import { cn } from "@/lib/utils";
 
@@ -67,6 +68,7 @@ export function SidebarHeader(props: SidebarHeaderProps) {
         <LoadGauge />
       </div>
       <div className="flex shrink-0 items-center gap-0.5">
+        <AwayToggle />
         <ADropdownMenu
           trigger={
             <Button