@saadnvd1/agent-os 0.3.591 → 0.3.594

package/app/api/bus/resurrect/route.test.ts

@@ -0,0 +1,47 @@
+import { NextRequest } from "next/server";
+import { describe, expect, it, vi } from "vitest";
+
+const resurrect = vi.hoisted(() => vi.fn());
+vi.mock("@/lib/resurrect", () => ({ resurrectSession: resurrect }));
+
+const { db } = await import("@/lib/db");
+const { seedWorkspace } = await import("@/lib/orchestrator/testing");
+const { POST } = await import("./route");
+
+const call = (body: object) =>
+  POST(
+    new NextRequest("http://localhost/api/bus/resurrect", {
+      method: "POST",
+      body: JSON.stringify(body),
+    })
+  );
+
+describe("POST /api/bus/resurrect (aos resurrect)", () => {
+  it("runs only from inside a session", async () => {
+    const res = await call({ session: "x" });
+    expect(res.status).toBe(409);
+    expect((await res.json()).error).toMatch(/inside an AgentOS session/);
+  });
+
+  it("reaches only the caller's workspace, and lists what ended with no session", async () => {
+    const mine = seedWorkspace("Bus mine");
+    const other = seedWorkspace("Bus other");
+    db.prepare(`UPDATE sessions SET task_status = 'dropped' WHERE id = ?`).run(
+      mine.task
+    );
+    db.prepare(`UPDATE sessions SET task_status = 'dropped' WHERE id = ?`).run(
+      other.task
+    );
+    const list = await (await call({ from: mine.chat })).json();
+    expect(list.sessions.map((s: { id: string }) => s.id)).toEqual([mine.task]);
+
+    const refused = await call({ from: mine.chat, session: other.task });
+    expect(refused.status).toBe(409);
+    expect(resurrect).not.toHaveBeenCalled();
+
+    resurrect.mockResolvedValueOnce({ text: "back" });
+    const ok = await call({ from: mine.chat, session: mine.task });
+    expect((await ok.json()).summary).toBe("back");
+    expect(resurrect).toHaveBeenCalledWith(mine.task);
+  });
+});

package/app/api/bus/resurrect/route.ts

@@ -0,0 +1,36 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getDoneTarget } from "@/lib/done";
+import { scopeOf } from "@/lib/done/bulk";
+import { resurrectSession } from "@/lib/resurrect";
+import { endedSessions, resolveEnded } from "@/lib/resurrect/find";
+
+// `aos resurrect [session]`, from inside a session: reaches only the
+// caller's workspace (or its project when it has none). Without a session it
+// lists the dropped and done ones that can come back.
+export async function POST(request: NextRequest) {
+  try {
+    const { from = null, session } = await request.json();
+    if (typeof from !== "string" || !from)
+      throw new Error("aos resurrect runs from inside an AgentOS session");
+    const scope = scopeOf(getDoneTarget(from));
+    if (typeof session !== "string" || !session.trim()) {
+      const ended = endedSessions(scope, { limit: 15 });
+      return NextResponse.json({
+        sessions: ended,
+        summary: ended.length
+          ? ended
+              .map(
+                (e) =>
+                  `${e.id.slice(0, 8)}  ${e.kind.padEnd(8)}  ${e.projectName ? `${e.projectName}/` : ""}${e.name}`
+              )
+              .join("\n")
+          : "Nothing dropped, done or archived to restore.",
+      });
+    }
+    const outcome = await resurrectSession(resolveEnded(session, scope));
+    return NextResponse.json({ summary: outcome.text, outcome });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 409 });
+  }
+}

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

@@ -89,8 +89,11 @@ export async function DELETE(
 ) {
   const { id } = await params;
   try {
-    await resumeNow(id, "person");
-    return NextResponse.json({ pause: pauseViewOf(id) });
+    const out = await resumeNow(id, "person");
+    return NextResponse.json({
+      pause: pauseViewOf(id),
+      ...(out.outcome === "held" && { note: out.note }),
+    });
   } catch (error) {
     return fail(error);
   }

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

@@ -0,0 +1,32 @@
+import { NextRequest } from "next/server";
+import { describe, expect, it, vi } from "vitest";
+
+const resurrect = vi.hoisted(() => vi.fn());
+vi.mock("@/lib/resurrect", () => ({ resurrectSession: resurrect }));
+
+const { POST } = await import("./route");
+
+const call = (id: string) =>
+  POST(
+    new NextRequest(`http://localhost/api/sessions/${id}/resurrect`, {
+      method: "POST",
+    }),
+    { params: Promise.resolve({ id }) }
+  );
+
+describe("POST /api/sessions/:id/resurrect", () => {
+  it("answers with the outcome", async () => {
+    resurrect.mockResolvedValueOnce({ id: "s1", text: "back" });
+    const res = await call("s1");
+    expect(res.status).toBe(200);
+    expect((await res.json()).outcome).toEqual({ id: "s1", text: "back" });
+    expect(resurrect).toHaveBeenCalledWith("s1", { device: null });
+  });
+
+  it("answers a refusal with 409 and the reason", async () => {
+    resurrect.mockRejectedValueOnce(new Error("its PR #3 was merged"));
+    const res = await call("s2");
+    expect(res.status).toBe(409);
+    expect(await res.json()).toEqual({ error: "its PR #3 was merged" });
+  });
+});

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

@@ -0,0 +1,24 @@
+import { NextRequest, NextResponse } from "next/server";
+import { resurrectSession } from "@/lib/resurrect";
+import { callingDevice } from "@/lib/security/device-me";
+import { db, queries, type Session } from "@/lib/db";
+
+// POST /api/sessions/:id/resurrect - bring a dropped, done or archived
+// session back: same id, same conversation, its status as it was. A refusal
+// (merged PR, conversation gone, project removed) is a 409 with the reason.
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const id = (await params).id;
+    const outcome = await resurrectSession(id, {
+      device: callingDevice(request),
+    });
+    const session = queries.getSession(db).get(id) as Session | undefined;
+    return NextResponse.json({ outcome, session });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 409 });
+  }
+}

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

@@ -0,0 +1,19 @@
+import { NextRequest, NextResponse } from "next/server";
+import { endedSessions, type EndedKind } from "@/lib/resurrect/find";
+
+const KINDS = new Set(["dropped", "done", "archived"]);
+
+// GET /api/sessions/ended[?workspace=id][&kind=dropped|done|archived][&limit=n]
+// - what can be restored, most recently ended first.
+export async function GET(request: NextRequest) {
+  const q = request.nextUrl.searchParams;
+  const workspace = q.get("workspace");
+  const kind = q.get("kind");
+  const limit = Math.min(Math.max(Number(q.get("limit")) || 50, 1), 200);
+  return NextResponse.json({
+    sessions: endedSessions(workspace ? { workspaceId: workspace } : null, {
+      limit,
+      kind: kind && KINDS.has(kind) ? (kind as EndedKind) : undefined,
+    }),
+  });
+}

package/app/globals.css

@@ -131,6 +131,17 @@
   animation: status-pulse 1.6s ease-in-out infinite;
 }
 
+/* Shown only once something has taken a moment: a quick send never flashes it. */
+@keyframes status-late {
+  from {
+    opacity: 0;
+  }
+}
+
+@utility status-late {
+  animation: status-late 0.2s ease-out 0.6s both;
+}
+
 @media (prefers-reduced-motion: reduce) {
   .status-live {
     animation: none;

package/components/Archived/ArchivedRow.tsx

@@ -3,7 +3,7 @@
 import { ArchiveRestore, ExternalLink, Loader2 } from "lucide-react";
 import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
-import { useUnarchiveSession } from "@/data/done";
+import { useResurrectSession } from "@/data/done";
 import type { ArchivedView } from "@/lib/done/archive";
 import { fromSqliteTime } from "@/lib/session-meta";
 
@@ -24,7 +24,7 @@ function when(at: string): string {
 }
 
 export function ArchivedRow({ session }: { session: ArchivedView }) {
-  const unarchive = useUnarchiveSession();
+  const restore = useResurrectSession();
   const kind = session.taskStatus ? STATUS[session.taskStatus] : "Session";
 
   return (
@@ -70,20 +70,24 @@ export function ArchivedRow({ session }: { session: ArchivedView }) {
               ? "Puts the entry back in the sidebar; its worktree was removed"
               : undefined
           }
-          disabled={unarchive.isPending}
+          disabled={restore.isPending}
           onClick={() =>
-            unarchive.mutate(session.id, {
-              onSuccess: () => toast.success(`${session.name} is back`),
+            restore.mutate(session.id, {
+              onSuccess: (outcome) => toast.success(outcome.text),
               onError: (e) => toast.error(e.message),
             })
           }
         >
-          {unarchive.isPending ? (
+          {restore.isPending ? (
             <Loader2 className="h-3.5 w-3.5 animate-spin" />
           ) : (
             <ArchiveRestore className="h-3.5 w-3.5" />
           )}
-          {session.worktreeRemoved ? "Restore entry" : "Unarchive"}
+          {session.taskStatus === "dropped"
+            ? "Restore"
+            : session.worktreeRemoved
+              ? "Restore entry"
+              : "Unarchive"}
         </Button>
       )}
     </div>

package/components/Chat/ChatPanel.tsx

@@ -51,6 +51,7 @@ import { FIND_EVENT, isFindKey, useFind } from "./useFind";
 import { McpServers } from "./McpServers";
 import { ArtifactCard } from "./Artifact";
 import { PlanCard } from "./PlanCard";
+import { ChatIdle } from "./idle";
 import { ContextMeter } from "./ContextMeter";
 import { SetupCard } from "./SetupCard";
 import { UserTurn } from "./EventRow";
@@ -77,6 +78,7 @@ import {
   CommandOutput,
   Compacted,
   SkillChip,
+  UserMessage,
   ErrorMessage,
   NoteLine,
   Reasoning,
@@ -86,10 +88,10 @@ import {
 
 interface ItemActions {
   respond: (id: string, answer: ApprovalDecision) => void;
-  // Absent while the agent is working, and inside undone messages.
+  // Absent inside undone messages; hidden while the agent works (ChatIdle).
   onCarryPlan?: (id: string) => void;
   onKeepPlanning?: () => void;
-  // Absent while the agent is working, and inside undone messages.
+  // Absent inside undone messages; hidden while the agent works (ChatIdle).
   onUndo?: (id: string) => void;
   onQuote?: (text: string) => void;
 }
@@ -294,6 +296,9 @@ export function ChatPanel({
     loadTaskOutput,
     taskOutputs,
     queue,
+    pending,
+    retrySend,
+    dropSend,
     queueEdit,
     queueMove,
     queueDelete,
@@ -606,12 +611,12 @@ export function ChatPanel({
   const actions: ItemActions = useMemo(
     () => ({
       respond,
-      onUndo: idle ? (id) => undo(id, true) : undefined,
-      onCarryPlan: idle ? carryPlan : undefined,
+      onUndo: (id) => undo(id, true),
+      onCarryPlan: carryPlan,
       onKeepPlanning: focusComposer,
       onQuote: (text) => setInsert(quoteInsert(text)),
     }),
-    [respond, idle, undo, carryPlan, focusComposer]
+    [respond, undo, carryPlan, focusComposer]
   );
 
   return (
@@ -653,13 +658,42 @@ export function ChatPanel({
                       </div>
                     )}
                     <SetupCard sessionId={sessionId} />
-                    {blocks.length === 0 && !queue.length && (
-                      <p className="text-muted-foreground py-16 text-center text-sm">
-                        Ask anything to start.
-                      </p>
-                    )}
+                    {blocks.length === 0 &&
+                      !queue.length &&
+                      !pending.length && (
+                        <p className="text-muted-foreground py-16 text-center text-sm">
+                          Ask anything to start.
+                        </p>
+                      )}
                   </div>
-                  <TimelineRows blocks={blocks} actions={actions} />
+                  <ChatIdle.Provider value={idle}>
+                    <TimelineRows blocks={blocks} actions={actions} />
+                  </ChatIdle.Provider>
+                  {pending.map((p) => (
+                    <div
+                      key={p.id}
+                      className="mx-auto w-full max-w-3xl px-4 pb-4"
+                    >
+                      <UserMessage
+                        item={{
+                          id: p.id,
+                          kind: "user",
+                          text: p.text,
+                          images: p.images,
+                          createdAt: p.at,
+                        }}
+                        pending={{
+                          status: p.status,
+                          error: p.error,
+                          onRetry: () => retrySend(p.id),
+                          onEdit: () => {
+                            dropSend(p.id);
+                            setPrefill({ text: p.text, at: Date.now() });
+                          },
+                        }}
+                      />
+                    </div>
+                  ))}
                 </div>
               </BookmarkChatContext.Provider>
             </ToolBodies.Provider>

package/components/Chat/Messages.test.ts

@@ -1,7 +1,7 @@
 import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
 import { describe, expect, it, vi } from "vitest";
-import { AssistantMessage } from "./Messages";
+import { AssistantMessage, UserMessage } from "./Messages";
 
 const item = {
   id: "a1",
@@ -47,3 +47,42 @@ describe("AssistantMessage quote action", () => {
     expect(html).not.toContain("Quote message");
   });
 });
+
+describe("a sent message not in the chat yet", () => {
+  const user = { id: "user-c-1", kind: "user", text: "An article" } as never;
+  const render = (status: "sending" | "accepted" | "failed") =>
+    renderToStaticMarkup(
+      createElement(UserMessage, {
+        item: user,
+        pending: {
+          status,
+          error: "connection lost",
+          onRetry: vi.fn(),
+          onEdit: vi.fn(),
+        },
+      })
+    );
+
+  it("shows the text at once, dimmed, with its progress", () => {
+    expect(render("sending")).toContain("An article");
+    expect(render("sending")).toContain("opacity-60");
+    expect(render("sending")).toContain("Sending");
+    expect(render("accepted")).toContain("Starting the agent");
+  });
+
+  it("says a failed one wasn't sent, with Retry and Edit", () => {
+    const html = render("failed");
+    expect(html).toContain("Not sent · connection lost");
+    expect(html).toContain(">Retry</button>");
+    expect(html).toContain(">Edit</button>");
+    expect(html).not.toContain("opacity-60");
+  });
+
+  it("a message in the chat shows no status", () => {
+    const html = renderToStaticMarkup(
+      createElement(UserMessage, { item: user })
+    );
+    expect(html).not.toContain("Sending");
+    expect(html).not.toContain("Not sent");
+  });
+});

package/components/Chat/Messages.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { memo } from "react";
 import {
   Check,
   ChevronRight,
@@ -9,6 +10,7 @@ import {
   Sparkles,
 } from "lucide-react";
 import type { ChatItem } from "@/lib/chat/events";
+import type { PendingSend } from "@/lib/chat/pending";
 import { cn } from "@/lib/utils";
 import { leadingCommand } from "@/lib/chat/commands";
 import { compactedLine } from "@/lib/chat/stale";
@@ -68,7 +70,9 @@ function Prose({ text }: { text: string }) {
   );
 }
 
-function UserText({ text }: { text: string }) {
+// Memoized: a chat full of pasted articles re-renders its rows when a turn
+// starts and ends, and splitting and linking each one again is the cost.
+const UserText = memo(function UserText({ text }: { text: string }) {
   return (
     <>
       {splitUserText(text).map((part, i) => {
@@ -89,45 +93,111 @@ function UserText({ text }: { text: string }) {
       })}
     </>
   );
+});
+
+// A sent message not in the chat yet (lib/chat/pending).
+export interface PendingStatus {
+  status: PendingSend["status"];
+  error?: string;
+  onRetry: () => void;
+  onEdit: () => void;
+}
+
+function StatusButton({
+  onClick,
+  children,
+}: {
+  onClick: () => void;
+  children: string;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      className="text-foreground hover:bg-foreground/[0.06] min-h-11 rounded-md px-2 underline underline-offset-2 md:min-h-7"
+    >
+      {children}
+    </button>
+  );
+}
+
+function SendStatus({ pending }: { pending: PendingStatus }) {
+  if (pending.status === "failed")
+    return (
+      <div
+        data-copy-skip
+        role="alert"
+        className="text-destructive flex items-center gap-1 font-mono text-[11px]"
+      >
+        <span>Not sent · {pending.error}</span>
+        <StatusButton onClick={pending.onRetry}>Retry</StatusButton>
+        <StatusButton onClick={pending.onEdit}>Edit</StatusButton>
+      </div>
+    );
+  return (
+    <div
+      data-copy-skip
+      aria-live="polite"
+      className="text-muted-foreground status-late flex items-center gap-1.5 font-mono text-[11px]"
+    >
+      <span className="status-live bg-muted-foreground h-1.5 w-1.5 rounded-full" />
+      {pending.status === "accepted" ? "Starting the agent" : "Sending"}
+    </div>
+  );
 }
 
 export function UserMessage({
   item,
   onUndo,
+  pending,
 }: {
   item: Of<"user">;
   onUndo?: () => void;
+  pending?: PendingStatus;
 }) {
-  return (
-    <BookmarkPress itemId={item.id}>
-      <div className="group flex flex-col items-end gap-1">
-        {item.from && (
-          <span data-copy-skip className="label-mono text-muted-foreground">
-            from {item.from}
-          </span>
-        )}
-        {item.images?.length ? (
-          <div data-copy-skip className="flex flex-wrap justify-end gap-1.5">
-            {item.images.map((img, i) => (
-              <ImageThumb
-                key={i}
-                src={`data:${img.mediaType};base64,${img.data}`}
-              />
-            ))}
-          </div>
-        ) : null}
-        {item.text && (
-          <div className="bg-foreground/[0.07] max-w-[85%] rounded-2xl rounded-br-md px-3.5 py-2 text-sm whitespace-pre-wrap">
-            <UserText text={item.text} />
-          </div>
-        )}
+  const message = (
+    <div className="group flex flex-col items-end gap-1">
+      {item.from && (
+        <span data-copy-skip className="label-mono text-muted-foreground">
+          from {item.from}
+        </span>
+      )}
+      {item.images?.length ? (
+        <div data-copy-skip className="flex flex-wrap justify-end gap-1.5">
+          {item.images.map((img, i) => (
+            <ImageThumb
+              key={i}
+              src={`data:${img.mediaType};base64,${img.data}`}
+            />
+          ))}
+        </div>
+      ) : null}
+      {item.text && (
+        <div
+          className={cn(
+            "bg-foreground/[0.07] max-w-[85%] rounded-2xl rounded-br-md px-3.5 py-2 text-sm whitespace-pre-wrap",
+            pending &&
+              (pending.status === "failed"
+                ? "ring-destructive ring-1 ring-inset"
+                : "opacity-60")
+          )}
+        >
+          <UserText text={item.text} />
+        </div>
+      )}
+      {pending ? (
+        <SendStatus pending={pending} />
+      ) : (
         <div className="-mr-1.5 flex items-center">
           {onUndo && <UndoButton onClick={onUndo} />}
           <BookmarkButton itemId={item.id} />
         </div>
-      </div>
-    </BookmarkPress>
+      )}
+    </div>
   );
+  // Not in the chat yet: nothing to star.
+  if (pending) return message;
+  return <BookmarkPress itemId={item.id}>{message}</BookmarkPress>;
 }
 
 export function AssistantMessage({

package/components/Chat/PausedBanner.tsx

@@ -28,7 +28,7 @@ export function PausedBanner({ sessionId }: { sessionId: string }) {
         className="h-4 w-4 shrink-0 text-amber-600 dark:text-amber-400"
       />
       <p className="min-w-0 flex-1 text-sm">
-        {pauseSubtitle({ state, until })}
+        {pauseSubtitle({ state, until, note: session.pause_note })}
         <span className="text-muted-foreground block text-xs">
           Messages you send now are held and delivered together when it resumes.
         </span>

package/components/Chat/PlanCard.tsx

@@ -3,6 +3,7 @@
 import { Check, ListChecks } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import type { ChatItem } from "@/lib/chat/events";
+import { useChatIdle } from "./idle";
 import { Markdown } from "./Markdown";
 
 type PlanItem = Extract<ChatItem, { kind: "plan" }>;
@@ -14,10 +15,11 @@ export function PlanCard({
   onKeepPlanning,
 }: {
   item: PlanItem;
-  // Absent while a turn runs.
+  // Absent inside undone messages; a running turn disables it too.
   onCarryOut?: () => void;
   onKeepPlanning: () => void;
 }) {
+  const idle = useChatIdle();
   return (
     <div className="bg-primary/[0.06] space-y-3 rounded-xl p-3">
       <div className="text-primary flex items-center gap-2 text-xs font-medium">
@@ -41,7 +43,7 @@ export function PlanCard({
           </Button>
           <Button
             className="h-11 md:h-9"
-            disabled={!onCarryOut}
+            disabled={!onCarryOut || !idle}
             onClick={onCarryOut}
           >
             Carry it out

package/components/Chat/Undo.tsx

@@ -14,6 +14,7 @@ import type { UndoPreview } from "@/lib/chat/events";
 import type { UndoItem } from "@/lib/chat/group";
 import { shortPath } from "@/lib/chat/diff";
 import { cn } from "@/lib/utils";
+import { useChatIdle } from "./idle";
 import { useRowState } from "./rowState";
 
 const counts = (p: { insertions?: number; deletions?: number }) =>
@@ -86,7 +87,9 @@ export function UndoDialog({
   );
 }
 
+// Shown only while the chat is idle.
 export function UndoButton({ onClick }: { onClick: () => void }) {
+  if (!useChatIdle()) return null;
   return (
     <button
       type="button"

package/components/Chat/idle.ts

@@ -0,0 +1,9 @@
+"use client";
+
+import { createContext, useContext } from "react";
+
+// Whether the chat can take an undo or carry out a plan (no turn running,
+// connected). A context rather than a prop, so a turn starting or ending
+// re-renders those buttons and not every row of a long conversation.
+export const ChatIdle = createContext(true);
+export const useChatIdle = () => useContext(ChatIdle);

package/components/SessionList/RowSubtitle.tsx

@@ -67,6 +67,7 @@ export function RowSubtitle({
             until: session.paused_until
               ? Date.parse(`${session.paused_until.replace(" ", "T")}Z`)
               : null,
+            note: session.pause_note,
           })}
         </span>
       ) : (