@saadnvd1/agent-os 0.3.826 → 0.3.833

package/README.md

@@ -68,6 +68,8 @@ It ends by offering `agent-os setup`. If another device can't reach the machine
 
 Then open AgentOS, add a project from ⌘K, and press ⌥N. The [install guide](docs/guides/install.md) covers Windows (WSL2), the supported agents, first run and the `agent-os` commands. To use it from your phone, see the [phone guide](docs/guides/phone.md).
 
+AgentOS keeps itself up to date: once a release is two hours old and nothing has been working for 10 minutes, it installs it, and puts the previous version back if the new one doesn't come up healthy. Turn it off or change the idle time in **Settings → Updates**, or pin it with `AGENTOS_AUTO_UPDATE=off` and `AGENTOS_AUTO_UPDATE_IDLE_MIN`. Details are in [Automatic updates](docs/guides/install.md#automatic-updates).
+
 ## Connect
 
 AgentOS Connect is live. It gives your machine a private address at runagentos.com, so your phone reaches it from any network with nothing to open on your router and no VPN.

package/app/layout.tsx

@@ -97,6 +97,9 @@ export default function RootLayout({
         </SerwistProvider>
         <Toaster
           position="top-center"
+          // Below the header, not over its title.
+          offset={{ top: 56 }}
+          mobileOffset={{ top: 64 }}
           closeButton
           toastOptions={{
             className: "!bg-card !border-border !text-foreground !shadow-lg",

package/components/Chat/ChatPanel.tsx

@@ -14,14 +14,11 @@ import { useChat } from "@/data/chat/useChat";
 import { PausedBanner } from "./PausedBanner";
 import { groupTimeline } from "@/lib/chat/group";
 import type { ChatItem } from "@/lib/chat/events";
-import {
-  isForkCommand,
-  isFreshCommand,
-  withFork,
-  withFresh,
-} from "@/lib/chat/commands";
+import { isFreshCommand, withFresh } from "@/lib/chat/commands";
 import { useExperiment } from "@/data/experiments";
-import { ForkDialog, ForksStrip } from "./Forks";
+import { useStartForks } from "@/data/fork";
+import { toast } from "sonner";
+import { ForksStrip, forkLabel } from "./Forks";
 import { ReplyingTo } from "./ReplyingTo";
 import { compactsFirst } from "@/lib/chat/pending";
 import { useFreshStart } from "@/data/sessions";
@@ -107,8 +104,14 @@ export function ChatPanel({
     append?: boolean;
   }>();
   const forksOn = useExperiment("forks");
-  const [forkOpen, setForkOpen] = useState(false);
-  const withForkIf = (c: typeof commands) => (forksOn ? withFork(c) : c);
+  const startFork = useStartForks(sessionId);
+  // Set while a selection is being forked; per session, like asIs below.
+  const [forkDraft, setForkDraft] = useState<{
+    sessionId: string;
+    quote: string;
+    own: boolean;
+  } | null>(null);
+  const fork = forksOn && forkDraft?.sessionId === sessionId ? forkDraft : null;
   const {
     items,
     hasMore,
@@ -187,12 +190,33 @@ export function ChatPanel({
     append?: boolean;
   }>();
 
+  // Leaving Fork mode keeps the selection as a normal quote in the draft.
+  const leaveFork = () => {
+    if (fork?.quote)
+      setInsert({
+        text: quoteMarkdown(fork.quote),
+        at: Date.now(),
+        append: true,
+      });
+    setForkDraft(null);
+  };
+
   // Esc sets the composer's ghost text aside, or else stops the turn
   // (lib/chat/escape), from anywhere in this panel.
   const rootRef = useRef<HTMLDivElement>(null);
-  const escape = useRef({ running, interrupt, suggestion });
+  const escape = useRef({
+    running,
+    interrupt,
+    suggestion,
+    leaveFork: null as (() => void) | null,
+  });
   useEffect(() => {
-    escape.current = { running, interrupt, suggestion };
+    escape.current = {
+      running,
+      interrupt,
+      suggestion,
+      leaveFork: fork ? leaveFork : null,
+    };
   });
   useEffect(() => {
     const onKey = (e: KeyboardEvent) => {
@@ -203,6 +227,17 @@ export function ChatPanel({
       const overlay = !!document.querySelector(OVERLAY_SELECTOR);
       const ghost = !!root.querySelector(GHOST_SELECTOR);
       const composer = (e.target as Element).closest?.(".chat-composer");
+      // Fork mode ends first; the typed text stays as a normal draft.
+      if (
+        e.key === "Escape" &&
+        escape.current.leaveFork &&
+        composer &&
+        !overlay
+      ) {
+        e.preventDefault();
+        escape.current.leaveFork();
+        return;
+      }
       const action = escapeAction(
         e,
         escape.current.running,
@@ -233,6 +268,10 @@ export function ChatPanel({
         setInsert({ text: quoteMarkdown(t), at: Date.now(), append: true }),
       focusComposer
     );
+  const forkQuote = (text: string) => {
+    setForkDraft({ sessionId, quote: text, own: false });
+    focusComposer();
+  };
   const togglePlan = plan === null ? undefined : () => setPlan(!plan);
   const sendText = (text: string) => {
     toEnd();
@@ -643,7 +682,11 @@ export function ChatPanel({
           onStop={stopTask}
           onLoadOutput={loadTaskOutput}
         />
-        <QuoteButton rootRef={scrollRef} onQuote={quote} />
+        <QuoteButton
+          rootRef={scrollRef}
+          onQuote={quote}
+          onFork={forksOn ? forkQuote : undefined}
+        />
         <PausedBanner sessionId={sessionId} />
         <ForksStrip sessionId={sessionId} />
         <Queue
@@ -682,14 +725,49 @@ export function ChatPanel({
           insert={insert}
           running={running}
           disabled={!connected}
-          placeholder={connected ? `Message ${sessionName}` : "Reconnecting…"}
+          placeholder={
+            !connected
+              ? "Reconnecting…"
+              : fork
+                ? "What should the fork do?"
+                : `Message ${sessionName}`
+          }
+          fork={
+            fork
+              ? {
+                  quote: fork.quote,
+                  own: fork.own,
+                  onOwn: () => setForkDraft({ ...fork, own: !fork.own }),
+                  onLeave: leaveFork,
+                  onDropQuote: () => setForkDraft({ ...fork, quote: "" }),
+                }
+              : undefined
+          }
           onSend={(text, images, files) => {
             if (freshStart && isFreshCommand(text)) {
               startFresh.mutate(sessionId);
               return;
             }
-            if (forksOn && isForkCommand(text)) {
-              setForkOpen(true);
+            if (fork) {
+              startFork.mutate(
+                {
+                  instructions: [(quoteMarkdown(fork.quote) + text).trim()],
+                  worktree: fork.own,
+                  // The result comes back by itself, as a card, without a message from the reader.
+                  delivery: "wake",
+                  labels: [forkLabel(text, fork.quote)],
+                },
+                {
+                  onSuccess: () => {
+                    toast.success("Started fork");
+                    setForkDraft(null);
+                  },
+                  onError: (e) => {
+                    toast.error(e.message);
+                    setInsert({ text, at: Date.now() });
+                  },
+                }
+              );
               return;
             }
             toEnd();
@@ -711,7 +789,7 @@ export function ChatPanel({
             }
           }}
           onStop={interrupt}
-          commands={withForkIf(freshStart ? withFresh(commands) : commands)}
+          commands={freshStart ? withFresh(commands) : commands}
           onRefreshCommands={refreshCommands}
           refreshingCommands={refreshingCommands}
           models={models}
@@ -731,13 +809,6 @@ export function ChatPanel({
           focusKey={active ? sessionId : null}
         />
       </div>
-      {forksOn && (
-        <ForkDialog
-          sessionId={sessionId}
-          open={forkOpen}
-          onOpenChange={setForkOpen}
-        />
-      )}
       {undoPreview && (
         <UndoDialog
           preview={undoPreview.preview}

package/components/Chat/EventRow.tsx

@@ -13,6 +13,7 @@ import {
 } from "lucide-react";
 import type { ChatItem, ChatOrigin, ChatOriginKind } from "@/lib/chat/events";
 import { eventParts, originOf } from "@/lib/chat/origin";
+import { ForkResults } from "./ForkResults";
 import { SessionAnchor } from "./SessionAnchor";
 import { cn } from "@/lib/utils";
 import { UserMessage } from "./Messages";
@@ -155,13 +156,24 @@ function Row({
 export function EventRow({
   item,
   origin,
+  onQuote,
 }: {
   item: UserItem;
   origin: ChatOrigin;
+  onQuote?: (text: string) => void;
 }) {
   const { body, decided } = eventParts(item, origin);
   const decidedLabel = `${ownerInUi(useOwnerName(), true)} decided`;
   const decision = origin.kind === "decision";
+  if (origin.forks)
+    return (
+      <ForkResults
+        parent={origin.forks.parent}
+        ids={origin.forks.ids}
+        fallback={body}
+        onQuote={onQuote}
+      />
+    );
   return (
     <div className="flex flex-col gap-1">
       {decided.map((d, i) => (
@@ -207,11 +219,13 @@ export function EventRow({
 export function UserTurn({
   item,
   onUndo,
+  onQuote,
 }: {
   item: UserItem;
   onUndo?: () => void;
+  onQuote?: (text: string) => void;
 }) {
   const origin = originOf(item);
-  if (origin) return <EventRow item={item} origin={origin} />;
+  if (origin) return <EventRow item={item} origin={origin} onQuote={onQuote} />;
   return <UserMessage item={item} onUndo={onUndo} />;
 }

package/components/Chat/ForkResults.tsx

@@ -0,0 +1,109 @@
+"use client";
+
+import { GitFork, Quote, RotateCcw } from "lucide-react";
+import { useForkChildren, type ChildView } from "@/data/fork";
+import { Button } from "@/components/ui/button";
+import { StatusPill } from "@/components/ui/status-pill";
+import { SessionAnchor } from "./SessionAnchor";
+import { emptyNote, stateLabel, useRunAgain } from "./Forks";
+
+const took = (c: ChildView) => {
+  if (!c.startedAt || !c.settledAt) return null;
+  const s = Math.max(1, Math.round((c.settledAt - c.startedAt) / 1000));
+  return s < 60
+    ? `${s}s`
+    : `${Math.floor(s / 60)}m ${String(s % 60).padStart(2, "0")}s`;
+};
+
+function Card({
+  c,
+  onQuote,
+  again,
+}: {
+  c: ChildView;
+  onQuote?: (text: string) => void;
+  again: ReturnType<typeof useRunAgain>;
+}) {
+  const { text, tone } = stateLabel(c);
+  const empty = c.outcome === "empty";
+  const body = empty ? emptyNote(c) : (c.excerpt ?? c.summary ?? "");
+  return (
+    <section
+      aria-label={`Fork ${c.n} result`}
+      className="bg-card popover-surface space-y-2 rounded-2xl p-3"
+    >
+      <div className="flex items-center gap-2">
+        <GitFork aria-hidden className="text-muted-foreground size-4" />
+        <span className="text-muted-foreground font-mono text-[11px] tracking-wider uppercase">
+          Fork {c.n}
+        </span>
+        <StatusPill tone={tone}>{text}</StatusPill>
+        <span className="text-muted-foreground ml-auto text-xs">{took(c)}</span>
+      </div>
+      <p className="text-sm font-medium">{c.label.replace(/^\d+\.\s*/, "")}</p>
+      <p
+        className={
+          empty
+            ? "text-sm text-amber-600 dark:text-amber-400"
+            : "text-muted-foreground line-clamp-6 text-sm whitespace-pre-wrap"
+        }
+      >
+        {body}
+      </p>
+      <div className="flex flex-wrap gap-2">
+        <Button asChild size="sm" className="min-h-11">
+          <SessionAnchor sessionId={c.id}>Open fork</SessionAnchor>
+        </Button>
+        {empty ? (
+          <Button
+            size="sm"
+            variant="secondary"
+            className="min-h-11"
+            disabled={again.pending}
+            onClick={() => again.run(c)}
+          >
+            <RotateCcw aria-hidden className="size-4" /> Run again
+          </Button>
+        ) : (
+          onQuote &&
+          body && (
+            <Button
+              size="sm"
+              variant="secondary"
+              className="min-h-11"
+              onClick={() => onQuote(c.excerpt ?? c.summary ?? "")}
+            >
+              <Quote aria-hidden className="size-4" /> Quote
+            </Button>
+          )
+        )}
+      </div>
+    </section>
+  );
+}
+
+// A delivery of fork results, as one card per fork in the parent's chat.
+export function ForkResults({
+  parent,
+  ids,
+  onQuote,
+  fallback,
+}: {
+  parent: string;
+  ids: string[];
+  fallback: string;
+  onQuote?: (text: string) => void;
+}) {
+  const { data } = useForkChildren(parent, true);
+  const again = useRunAgain(parent);
+  const cards = (data?.children ?? []).filter((c) => ids.includes(c.id));
+  if (!cards.length)
+    return <p className="text-muted-foreground text-xs">{fallback}</p>;
+  return (
+    <div className="flex flex-col gap-2">
+      {cards.map((c) => (
+        <Card key={c.id} c={c} onQuote={onQuote} again={again} />
+      ))}
+    </div>
+  );
+}

package/components/Chat/Forks.tsx

@@ -1,10 +1,9 @@
 "use client";
 
 import { useState } from "react";
-import { GitFork, Plus, Square } from "lucide-react";
+import { GitFork, Square } from "lucide-react";
 import { toast } from "sonner";
 import { useExperiment } from "@/data/experiments";
-import { useClientConfig } from "@/data/client-config/queries";
 import {
   useCancelForks,
   useForkChildren,
@@ -12,17 +11,7 @@ import {
   type ChildView,
 } from "@/data/fork";
 import { Button } from "@/components/ui/button";
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from "@/components/ui/dialog";
 import { StatusPill } from "@/components/ui/status-pill";
-import { Switch } from "@/components/ui/switch";
-import { Textarea } from "@/components/ui/textarea";
 import { SessionAnchor } from "./SessionAnchor";
 
 type Tone = "amber" | "muted" | "green" | "primary" | "red";
@@ -34,22 +23,55 @@ export function stateLabel(c: ChildView): { text: string; tone: Tone } {
   if (c.state === "needs_input") return { text: "Needs you", tone: "amber" };
   if (c.outcome === "failed") return { text: "Failed", tone: "red" };
   if (c.outcome === "cancelled") return { text: "Stopped", tone: "muted" };
+  if (c.outcome === "empty") return { text: "No result", tone: "amber" };
   return { text: "Done", tone: "green" };
 }
 
+// The strip's name for a fork: what was asked, else what was quoted, so a
+// quote-first instruction isn't labelled with its "> ".
+export const forkLabel = (typed: string, quote: string): string => {
+  const line = (typed.trim() || quote.trim()).split("\n")[0].trim();
+  return line.length > 60 ? `${line.slice(0, 59)}…` : line;
+};
+
+// What a fork that ended with nothing to read says in place of a result.
+export const emptyNote = (c: ChildView) =>
+  c.summary && c.summary !== "ended without a result"
+    ? `Ended with “${c.summary}”, not an answer`
+    : "Ended without a result";
+
+// Starts the same instruction again, for a fork that came back with nothing.
+export function useRunAgain(sessionId: string) {
+  const start = useStartForks(sessionId);
+  return {
+    pending: start.isPending,
+    run: (c: ChildView) =>
+      start.mutate(
+        { instructions: [c.instruction], worktree: c.worktree },
+        {
+          onSuccess: () => toast.success("Started fork"),
+          onError: (e) => toast.error(e.message),
+        }
+      ),
+  };
+}
+
 function Row({
   c,
   onStop,
   stopping,
+  again,
 }: {
   c: ChildView;
+  again: ReturnType<typeof useRunAgain>;
   onStop: () => void;
   stopping: boolean;
 }) {
   const { text, tone } = stateLabel(c);
   const open = c.state !== "settled";
+  const empty = c.outcome === "empty";
   const note =
-    c.summary ??
+    (empty ? emptyNote(c) : c.summary) ??
     (c.asks
       ? `Asks: ${c.asks}`
       : c.state === "queued"
@@ -65,7 +87,13 @@ function Row({
           {c.n}. {c.label.replace(/^\d+\.\s*/, "")}
         </p>
         {note && (
-          <p className="text-muted-foreground truncate text-xs">
+          <p
+            className={
+              empty
+                ? "truncate text-xs text-amber-600 dark:text-amber-400"
+                : "text-muted-foreground truncate text-xs"
+            }
+          >
             {note}
             {c.resultKind === "implicit" && c.outcome === "ok"
               ? " · ended without reporting"
@@ -73,6 +101,16 @@ function Row({
           </p>
         )}
       </div>
+      {empty && (
+        <button
+          type="button"
+          disabled={again.pending}
+          onClick={() => again.run(c)}
+          className="text-primary flex min-h-11 shrink-0 items-center px-2 text-sm"
+        >
+          Run again
+        </button>
+      )}
       <SessionAnchor
         sessionId={c.id}
         className="text-primary flex min-h-11 shrink-0 items-center px-2 text-sm"
@@ -100,6 +138,7 @@ export function ForksStrip({ sessionId }: { sessionId: string }) {
   const on = useExperiment("forks");
   const { data } = useForkChildren(sessionId, on);
   const cancel = useCancelForks(sessionId);
+  const again = useRunAgain(sessionId);
   const [collapsed, setCollapsed] = useState(false);
   if (!on || !data) return null;
   if (data.asChild) return <ForkOfBanner info={data.asChild} />;
@@ -150,6 +189,7 @@ export function ForksStrip({ sessionId }: { sessionId: string }) {
               key={c.id}
               c={c}
               stopping={cancel.isPending}
+              again={again}
               onStop={() => stop(String(c.n))}
             />
           ))}
@@ -187,92 +227,3 @@ function ForkOfBanner({
     </section>
   );
 }
-
-// "/fork": instructions for N copies of this session.
-export function ForkDialog({
-  sessionId,
-  open,
-  onOpenChange,
-}: {
-  sessionId: string;
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-}) {
-  const start = useStartForks(sessionId);
-  const max = useClientConfig().data?.forks?.maxPerFork ?? 8;
-  const [texts, setTexts] = useState<string[]>([""]);
-  const [worktree, setWorktree] = useState(false);
-  const filled = texts.map((t) => t.trim()).filter(Boolean);
-  const submit = () =>
-    start.mutate(
-      { instructions: filled, worktree },
-      {
-        onSuccess: (r) => {
-          toast.success(
-            `Started ${r.children.length} ${r.children.length === 1 ? "fork" : "forks"}`
-          );
-          setTexts([""]);
-          setWorktree(false);
-          onOpenChange(false);
-        },
-        onError: (e) => toast.error(e.message),
-      }
-    );
-  return (
-    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="max-h-[90dvh] overflow-y-auto sm:max-w-lg">
-        <DialogHeader>
-          <DialogTitle>Fork this session</DialogTitle>
-          <DialogDescription>
-            Each copy knows what this session knows and works in the background.
-            You keep going; results are added to your next message.
-          </DialogDescription>
-        </DialogHeader>
-        <div className="space-y-2">
-          {texts.map((t, i) => (
-            <Textarea
-              key={i}
-              value={t}
-              rows={2}
-              aria-label={`Fork ${i + 1}`}
-              placeholder={`What should fork ${i + 1} do?`}
-              onChange={(e) =>
-                setTexts(texts.map((x, j) => (j === i ? e.target.value : x)))
-              }
-            />
-          ))}
-          {texts.length < max && (
-            <Button
-              type="button"
-              variant="ghost"
-              size="sm"
-              className="min-h-11"
-              onClick={() => setTexts([...texts, ""])}
-            >
-              <Plus aria-hidden className="size-4" /> Another
-            </Button>
-          )}
-          <label className="flex min-h-11 items-center justify-between gap-3 text-sm">
-            <span>
-              Own checkout
-              <span className="text-muted-foreground block text-xs">
-                For forks that edit code. Off: they read this checkout and leave
-                it alone.
-              </span>
-            </span>
-            <Switch checked={worktree} onCheckedChange={setWorktree} />
-          </label>
-        </div>
-        <DialogFooter>
-          <Button
-            className="min-h-11"
-            disabled={!filled.length || start.isPending}
-            onClick={submit}
-          >
-            {filled.length > 1 ? `Start ${filled.length} forks` : "Start fork"}
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-  );
-}