stagent 0.9.5 → 0.10.0

package/src/components/instance/upgrade-badge.tsx

@@ -0,0 +1,219 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { useRouter } from "next/navigation";
+import { ArrowUpCircle } from "lucide-react";
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogDescription,
+  DialogFooter,
+  DialogTrigger,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import type { UpgradeState } from "@/lib/instance/types";
+
+interface InstanceConfig {
+  instanceId: string;
+  branchName: string;
+  isPrivateInstance: boolean;
+  createdAt: number;
+}
+
+interface ConfigResponse {
+  devMode?: boolean;
+  config: InstanceConfig | null;
+  upgrade: UpgradeState | null;
+}
+
+type StatusResponse = UpgradeState & { devMode?: boolean };
+
+/**
+ * Sidebar upgrade badge + pre-flight modal combined into a single Client
+ * Component. Fetches status on mount and every 5 minutes; renders nothing
+ * when no upgrade is available. When clicked, opens the pre-flight modal
+ * and loads the full config for the fact panel.
+ *
+ * Combined into one component because Next.js 16's stricter client/server
+ * boundary rules reject passing callback props between separately-imported
+ * client components unless they're Server Actions. Bundling the two here
+ * preserves the spec's separation of concerns at the design level while
+ * satisfying the framework.
+ */
+export function UpgradeBadge() {
+  const router = useRouter();
+  const [state, setState] = useState<StatusResponse | null>(null);
+  const [open, setOpen] = useState(false);
+  const [config, setConfig] = useState<ConfigResponse | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [starting, setStarting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function fetchStatus() {
+      try {
+        const res = await fetch("/api/instance/upgrade/status", {
+          cache: "no-store",
+        });
+        if (!res.ok) return;
+        const data = (await res.json()) as StatusResponse;
+        if (!cancelled) setState(data);
+      } catch {
+        // Silent — the badge is ambient; status fetch failures should not
+        // produce UI noise. Persistent poll failures surface as a warning
+        // variant via state.pollFailureCount >= 3.
+      }
+    }
+
+    fetchStatus();
+    const interval = setInterval(fetchStatus, 5 * 60 * 1000);
+    // Refetch when the tab regains focus — picks up DB changes made by the
+    // hourly poller or by a manual "Check for upgrades" click while the user
+    // was running git commands in the terminal.
+    window.addEventListener("focus", fetchStatus);
+    return () => {
+      cancelled = true;
+      clearInterval(interval);
+      window.removeEventListener("focus", fetchStatus);
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!open) return;
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    (async () => {
+      try {
+        const res = await fetch("/api/instance/config", { cache: "no-store" });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const data = (await res.json()) as ConfigResponse;
+        if (!cancelled) setConfig(data);
+      } catch (err) {
+        if (!cancelled) setError(err instanceof Error ? err.message : String(err));
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [open]);
+
+  async function startUpgrade() {
+    setStarting(true);
+    setError(null);
+    try {
+      const res = await fetch("/api/instance/upgrade", { method: "POST" });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new Error(body.error ?? `HTTP ${res.status}`);
+      }
+      const data = (await res.json()) as { taskId: string };
+      setOpen(false);
+      router.push(`/tasks/${data.taskId}`);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setStarting(false);
+    }
+  }
+
+  if (!state || state.devMode || !state.upgradeAvailable) return null;
+
+  const failing = state.pollFailureCount >= 3;
+  const count = state.commitsBehind;
+  const label = failing
+    ? "Check failing"
+    : `${count} update${count === 1 ? "" : "s"}`;
+  const tooltip = failing
+    ? "Upgrade check failing — click to retry"
+    : `${count} upstream update${count === 1 ? "" : "s"} ready to merge`;
+  const buttonClass = failing
+    ? "h-7 px-2 rounded-md border border-amber-500/40 bg-amber-500/10 text-[11px] font-medium text-amber-700 dark:text-amber-400 hover:bg-amber-500/20 transition-colors cursor-pointer inline-flex items-center gap-1.5 group-data-[collapsible=icon]:hidden"
+    : "h-7 px-2 rounded-md border border-blue-500/40 bg-blue-500/10 text-[11px] font-medium text-blue-700 dark:text-blue-400 hover:bg-blue-500/20 transition-colors cursor-pointer inline-flex items-center gap-1.5 group-data-[collapsible=icon]:hidden";
+
+  const modalUpgrade = config?.upgrade ?? null;
+  const modalCount = modalUpgrade?.commitsBehind ?? count;
+  const lastUpgradeText = modalUpgrade?.lastSuccessfulUpgradeAt
+    ? new Date(modalUpgrade.lastSuccessfulUpgradeAt * 1000).toLocaleString()
+    : "never";
+
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        <button
+          type="button"
+          aria-label={tooltip}
+          title={tooltip}
+          className={buttonClass}
+          onClick={(e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            setOpen(true);
+          }}
+        >
+          <ArrowUpCircle className="h-3 w-3" aria-hidden />
+          <span>{label}</span>
+        </button>
+      </DialogTrigger>
+      <DialogContent className="sm:max-w-lg">
+        <DialogHeader>
+          <DialogTitle>Upgrade available</DialogTitle>
+          <DialogDescription>
+            {modalCount} commit{modalCount === 1 ? "" : "s"} ready to merge into{" "}
+            <code className="font-mono text-xs">
+              {config?.config?.branchName ?? "…"}
+            </code>
+          </DialogDescription>
+        </DialogHeader>
+
+        {loading && (
+          <div className="py-4 text-sm text-muted-foreground">Loading instance state…</div>
+        )}
+
+        {error && (
+          <div className="rounded-md border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+            {error}
+          </div>
+        )}
+
+        {config && !loading && (
+          <div className="space-y-3 py-2">
+            <div className="grid grid-cols-[auto_1fr] gap-x-4 gap-y-2 text-sm">
+              <span className="text-muted-foreground">Branch</span>
+              <code className="font-mono text-xs">{config.config?.branchName ?? "—"}</code>
+              <span className="text-muted-foreground">Data directory</span>
+              <code className="font-mono text-xs break-all">
+                {config.config?.isPrivateInstance ? "custom" : "default"}
+              </code>
+              <span className="text-muted-foreground">Commits behind</span>
+              <span>{modalCount}</span>
+              <span className="text-muted-foreground">Last successful upgrade</span>
+              <span>{lastUpgradeText}</span>
+            </div>
+
+            <p className="text-sm text-muted-foreground leading-relaxed">
+              Stagent will stash any uncommitted work, merge <code className="font-mono">main</code> into{" "}
+              <code className="font-mono">{config.config?.branchName ?? "your branch"}</code>, install any new
+              dependencies, and ask you to resolve conflicts if any appear.
+            </p>
+          </div>
+        )}
+
+        <DialogFooter>
+          <Button variant="ghost" onClick={() => setOpen(false)} disabled={starting}>
+            Cancel
+          </Button>
+          <Button onClick={startUpgrade} disabled={loading || starting || !config?.config}>
+            {starting ? "Starting…" : "Start upgrade"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

package/src/components/notifications/__tests__/batch-proposal-review.test.tsx

@@ -0,0 +1,95 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+
+import { BatchProposalReview } from "@/components/notifications/batch-proposal-review";
+
+const { toastError } = vi.hoisted(() => ({
+  toastError: vi.fn(),
+}));
+
+vi.mock("sonner", () => ({
+  toast: {
+    error: toastError,
+  },
+}));
+
+describe("batch proposal review", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("optimistically resolves the batch before the request finishes", async () => {
+    const onResponded = vi.fn();
+    let resolveFetch: ((value: Response) => void) | null = null;
+
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockImplementation(
+        () =>
+          new Promise<Response>((resolve) => {
+            resolveFetch = resolve;
+          })
+      )
+    );
+
+    render(
+      <BatchProposalReview
+        proposalIds={["p1", "p2"]}
+        profileIds={["general"]}
+        body="Batch summary"
+        onResponded={onResponded}
+      />
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: /approve all/i }));
+
+    expect(onResponded).toHaveBeenCalledTimes(1);
+
+    resolveFetch?.(
+      new Response(JSON.stringify({ action: "approve", count: 2 }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      })
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText("2 proposals approved")).toBeInTheDocument();
+    });
+  });
+
+  it("restores server truth when the batch request fails", async () => {
+    const onResponded = vi.fn();
+    const onRequestFailed = vi.fn();
+
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockRejectedValue(new Error("Batch approval failed"))
+    );
+
+    render(
+      <BatchProposalReview
+        proposalIds={["p1", "p2"]}
+        profileIds={["general"]}
+        body="Batch summary"
+        onResponded={onResponded}
+        onRequestFailed={onRequestFailed}
+      />
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: /approve all/i }));
+
+    expect(onResponded).toHaveBeenCalledTimes(1);
+
+    await waitFor(() => {
+      expect(onRequestFailed).toHaveBeenCalledTimes(1);
+    });
+    expect(toastError).toHaveBeenCalledWith("Batch approval failed");
+    expect(
+      screen.getByRole("button", { name: /approve all \(2\)/i })
+    ).toBeInTheDocument();
+  });
+});

package/src/components/notifications/__tests__/notification-item.test.tsx

@@ -0,0 +1,106 @@
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+
+import { NotificationItem } from "@/components/notifications/notification-item";
+
+const { push, contextReviewSpy, batchReviewSpy } = vi.hoisted(() => ({
+  push: vi.fn(),
+  contextReviewSpy: vi.fn(),
+  batchReviewSpy: vi.fn(),
+}));
+
+vi.mock("next/navigation", () => ({
+  useRouter: () => ({ push }),
+}));
+
+vi.mock("@/components/profiles/context-proposal-review", () => ({
+  ContextProposalReview: (props: {
+    notificationId: string;
+    profileId: string;
+    proposedAdditions: string;
+    onResponded: () => void;
+  }) => {
+    contextReviewSpy(props);
+    return <div>Context proposal review</div>;
+  },
+}));
+
+vi.mock("@/components/notifications/batch-proposal-review", () => ({
+  BatchProposalReview: (props: {
+    proposalIds: string[];
+    profileIds: string[];
+    body: string;
+    onResponded?: () => void;
+  }) => {
+    batchReviewSpy(props);
+    return <div>Batch proposal review</div>;
+  },
+}));
+
+describe("notification item", () => {
+  it("renders context proposal review actions using the full additions payload", () => {
+    render(
+      <NotificationItem
+        notification={{
+          id: "notif-1",
+          taskId: null,
+          type: "context_proposal",
+          title: "Context proposal",
+          body: "truncated body",
+          read: false,
+          toolName: "general",
+          toolInput: JSON.stringify({
+            profileId: "general",
+            additions: "Full learned additions",
+          }),
+          response: null,
+          respondedAt: null,
+          createdAt: "2026-04-10T00:00:00.000Z",
+        }}
+        onUpdated={vi.fn()}
+      />
+    );
+
+    expect(screen.getByText("Context proposal review")).toBeInTheDocument();
+    expect(contextReviewSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        notificationId: "notif-1",
+        profileId: "general",
+        proposedAdditions: "Full learned additions",
+      })
+    );
+  });
+
+  it("renders batch proposal review actions for workflow learning notifications", () => {
+    render(
+      <NotificationItem
+        notification={{
+          id: "notif-2",
+          taskId: null,
+          type: "context_proposal_batch",
+          title: "Workflow learning batch",
+          body: "Batch summary",
+          read: false,
+          toolName: "workflow-context-batch",
+          toolInput: JSON.stringify({
+            proposalIds: ["p1", "p2"],
+            profileIds: ["general", "researcher"],
+          }),
+          response: null,
+          respondedAt: null,
+          createdAt: "2026-04-10T00:00:00.000Z",
+        }}
+        onUpdated={vi.fn()}
+      />
+    );
+
+    expect(screen.getByText("Batch proposal review")).toBeInTheDocument();
+    expect(batchReviewSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        proposalIds: ["p1", "p2"],
+        profileIds: ["general", "researcher"],
+        body: "Batch summary",
+      })
+    );
+  });
+});

package/src/components/notifications/batch-proposal-review.tsx

@@ -1,6 +1,7 @@
 "use client";
 
 import { useState } from "react";
+import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
 import { Badge } from "@/components/ui/badge";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
@@ -12,6 +13,7 @@ interface BatchProposalReviewProps {
   profileIds: string[];
   body: string;
   onResponded?: () => void;
+  onRequestFailed?: () => void;
   compact?: boolean;
 }
 
@@ -20,6 +22,7 @@ export function BatchProposalReview({
   profileIds,
   body,
   onResponded,
+  onRequestFailed,
   compact = false,
 }: BatchProposalReviewProps) {
   const [loading, setLoading] = useState<"approve" | "reject" | null>(null);
@@ -31,18 +34,30 @@ export function BatchProposalReview({
 
   async function handleBatchAction(action: "approve" | "reject") {
     setLoading(action);
+    setResponded(true);
+    onResponded?.();
+
     try {
       const res = await fetch("/api/context/batch", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ proposalIds, action }),
       });
-      if (res.ok) {
-        const data = await res.json();
-        setResult({ action: data.action, count: data.count });
-        setResponded(true);
-        onResponded?.();
+
+      if (!res.ok) {
+        const data = await res.json().catch(() => null);
+        throw new Error(data?.error ?? `Failed to ${action} batch proposal`);
       }
+
+      const data = await res.json();
+      setResult({ action: data.action, count: data.count });
+    } catch (error) {
+      setResponded(false);
+      setResult(null);
+      toast.error(
+        error instanceof Error ? error.message : "Batch approval failed"
+      );
+      onRequestFailed?.();
     } finally {
       setLoading(null);
     }

package/src/components/notifications/inbox-list.tsx

@@ -7,6 +7,7 @@ import { Eye, Inbox, RefreshCw, Trash2 } from "lucide-react";
 import { toast } from "sonner";
 import { NotificationItem } from "./notification-item";
 import { EmptyState } from "@/components/shared/empty-state";
+import { filterDefaultVisibleNotifications } from "@/lib/notifications/visibility";
 
 interface Notification {
   id: string;
@@ -28,12 +29,15 @@ export function InboxList({
   initialNotifications: Notification[];
 }) {
   const [notifications, setNotifications] =
-    useState<Notification[]>(initialNotifications);
+    useState<Notification[]>(() => filterDefaultVisibleNotifications(initialNotifications));
   const [tab, setTab] = useState("all");
 
   const refresh = useCallback(async () => {
     const res = await fetch("/api/notifications");
-    if (res.ok) setNotifications(await res.json());
+    if (res.ok) {
+      const next = (await res.json()) as Notification[];
+      setNotifications(filterDefaultVisibleNotifications(next));
+    }
   }, []);
 
   // Poll every 10 seconds (consolidated from 3s inbox + 5s badge)
@@ -154,6 +158,11 @@ export function InboxList({
             <NotificationItem
               key={n.id}
               notification={n}
+              onRemoved={(notificationId) =>
+                setNotifications((current) =>
+                  current.filter((item) => item.id !== notificationId)
+                )
+              }
               onUpdated={refresh}
             />
           ))

package/src/components/notifications/notification-item.tsx

@@ -18,6 +18,8 @@ import {
   parseNotificationToolInput,
   type PermissionToolInput,
 } from "@/lib/notifications/permissions";
+import { ContextProposalReview } from "@/components/profiles/context-proposal-review";
+import { BatchProposalReview } from "./batch-proposal-review";
 
 interface Notification {
   id: string;
@@ -35,6 +37,7 @@ interface Notification {
 
 interface NotificationItemProps {
   notification: Notification;
+  onRemoved?: (notificationId: string) => void;
   onUpdated: () => void;
 }
 
@@ -104,7 +107,25 @@ function formatToolInput(
 
 const navigableTypes = new Set(["task_completed", "task_failed", "permission_required", "agent_message"]);
 
-export function NotificationItem({ notification, onUpdated }: NotificationItemProps) {
+function parseBatchToolInput(toolInput: PermissionToolInput | null): {
+  proposalIds: string[];
+  profileIds: string[];
+} {
+  return {
+    proposalIds: Array.isArray(toolInput?.proposalIds)
+      ? toolInput.proposalIds.filter((id): id is string => typeof id === "string")
+      : [],
+    profileIds: Array.isArray(toolInput?.profileIds)
+      ? toolInput.profileIds.filter((id): id is string => typeof id === "string")
+      : [],
+  };
+}
+
+export function NotificationItem({
+  notification,
+  onRemoved,
+  onUpdated,
+}: NotificationItemProps) {
   const router = useRouter();
   const [toggling, setToggling] = useState(false);
   const [dismissing, setDismissing] = useState(false);
@@ -212,7 +233,9 @@ export function NotificationItem({ notification, onUpdated }: NotificationItemPr
           {/* Body for non-tool notifications */}
           {notification.body &&
             notification.type !== "permission_required" &&
-            notification.type !== "agent_message" && (
+            notification.type !== "agent_message" &&
+            notification.type !== "context_proposal" &&
+            notification.type !== "context_proposal_batch" && (
               <div className="mt-1" onClick={(e) => e.stopPropagation()}>
                 <div
                   className={`${PROSE_NOTIFICATION} ${
@@ -270,6 +293,37 @@ export function NotificationItem({ notification, onUpdated }: NotificationItemPr
             <FailureAction taskId={notification.taskId} onRetried={onUpdated} />
           )}
 
+          {notification.type === "context_proposal" && (
+            <div className="mt-3" onClick={(e) => e.stopPropagation()}>
+              <ContextProposalReview
+                notificationId={notification.id}
+                profileId={
+                  typeof parsedToolInput?.profileId === "string"
+                    ? parsedToolInput.profileId
+                    : (notification.toolName ?? "")
+                }
+                proposedAdditions={
+                  typeof parsedToolInput?.additions === "string"
+                    ? parsedToolInput.additions
+                    : (notification.body ?? "")
+                }
+                onResponded={onUpdated}
+              />
+            </div>
+          )}
+
+          {notification.type === "context_proposal_batch" && (
+            <div className="mt-3" onClick={(e) => e.stopPropagation()}>
+              <BatchProposalReview
+                proposalIds={parseBatchToolInput(parsedToolInput).proposalIds}
+                profileIds={parseBatchToolInput(parsedToolInput).profileIds}
+                body={notification.body ?? ""}
+                onResponded={() => onRemoved?.(notification.id)}
+                onRequestFailed={onUpdated}
+              />
+            </div>
+          )}
+
           <p className="text-xs text-muted-foreground mt-2">
             {formatTimestamp(notification.createdAt)}
             {notification.respondedAt && (