@saadnvd1/agent-os 0.3.828 → 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>
-  );
-}

package/components/Chat/QuoteButton.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { useEffect, useId, useState, type RefObject } from "react";
-import { Quote } from "lucide-react";
+import { GitFork, Quote } from "lucide-react";
 import { cn } from "@/lib/utils";
 import { useCoarsePointer } from "./composer/useCoarsePointer";
 import { useKeybindings } from "@/hooks/useKeybindings";
@@ -19,7 +19,7 @@ interface Picked {
   at: Placement | null;
 }
 
-function readSelection(root: HTMLElement): Picked | null {
+function readSelection(root: HTMLElement, half?: number): Picked | null {
   const sel = window.getSelection();
   const pick = sel && quotePick(sel, root);
   if (!pick) return null;
@@ -30,7 +30,10 @@ function readSelection(root: HTMLElement): Picked | null {
     left: Math.min(...rects.map((r) => r.left)),
     right: Math.max(...rects.map((r) => r.right)),
   };
-  return { text: pick.text, at: placeQuote(box, root.getBoundingClientRect()) };
+  return {
+    text: pick.text,
+    at: placeQuote(box, root.getBoundingClientRect(), undefined, half),
+  };
 }
 
 // "Quote" for a selection in a reply. With a mouse it floats over the
@@ -39,12 +42,16 @@ function readSelection(root: HTMLElement): Picked | null {
 export function QuoteButton({
   rootRef,
   onQuote,
+  onFork,
 }: {
   rootRef: RefObject<HTMLElement | null>;
   onQuote: (text: string) => void;
+  // Only given while forks are on: a second button beside Quote.
+  onFork?: (text: string) => void;
 }) {
   const [picked, setPicked] = useState<Picked | null>(null);
   const coarse = useCoarsePointer();
+  const wide = !!onFork;
 
   useEffect(() => {
     let frame = 0;
@@ -52,7 +59,7 @@ export function QuoteButton({
       cancelAnimationFrame(frame);
       frame = requestAnimationFrame(() => {
         const root = rootRef.current;
-        setPicked(root ? readSelection(root) : null);
+        setPicked(root ? readSelection(root, wide ? 110 : undefined) : null);
       });
     };
     document.addEventListener("selectionchange", update);
@@ -62,7 +69,7 @@ export function QuoteButton({
       document.removeEventListener("selectionchange", update);
       window.removeEventListener("scroll", update, true);
     };
-  }, [rootRef]);
+  }, [rootRef, wide]);
 
   const shown = !!picked && (coarse || !!picked.at);
   const quote = quoteAction(picked?.text, {
@@ -70,27 +77,58 @@ export function QuoteButton({
     clearSelection: () => window.getSelection()?.removeAllRanges(),
     hide: () => setPicked(null),
   });
+  const fork = quoteAction(picked?.text, {
+    onQuote: onFork ?? onQuote,
+    clearSelection: () => window.getSelection()?.removeAllRanges(),
+    hide: () => setPicked(null),
+  });
   // One source per button: each open chat pane has its own.
-  useKeybindings(`chat-quote:${useId()}`, [quoteEnter(shown, quote)]);
+  useKeybindings(`chat-quote:${useId()}`, [
+    quoteEnter(shown, quote),
+    ...(onFork
+      ? [{ ...quoteEnter(shown, fork), id: "chat.fork", keys: "f" }]
+      : []),
+  ]);
 
   if (!picked) return null;
+  const pill =
+    "bg-card popover-surface hover:bg-muted flex min-h-11 items-center gap-1.5 rounded-full px-3.5 text-sm font-medium md:min-h-8 md:px-3 pointer-coarse:min-h-11";
   const button = (
-    <button
-      type="button"
-      // Pressing it mustn't clear the selection before it's read.
-      onMouseDown={(e) => e.preventDefault()}
-      onClick={quote}
-      className="bg-card popover-surface hover:bg-muted flex min-h-11 items-center gap-1.5 rounded-full px-3.5 text-sm font-medium md:min-h-8 md:px-3 pointer-coarse:min-h-11"
-    >
-      <Quote className="h-3.5 w-3.5" />
-      Quote
-      <kbd
-        aria-hidden
-        className="text-muted-foreground bg-muted hidden rounded px-1 font-mono text-[10px] leading-4 md:inline"
+    <div className="flex items-center gap-1.5">
+      <button
+        type="button"
+        // Pressing it mustn't clear the selection before it's read.
+        onMouseDown={(e) => e.preventDefault()}
+        onClick={quote}
+        className={pill}
       >
-        ↵
-      </kbd>
-    </button>
+        <Quote className="h-3.5 w-3.5" />
+        Quote
+        <kbd
+          aria-hidden
+          className="text-muted-foreground bg-muted hidden rounded px-1 font-mono text-[10px] leading-4 md:inline"
+        >
+          ↵
+        </kbd>
+      </button>
+      {onFork && (
+        <button
+          type="button"
+          onMouseDown={(e) => e.preventDefault()}
+          onClick={fork}
+          className={pill}
+        >
+          <GitFork className="h-3.5 w-3.5" />
+          Fork
+          <kbd
+            aria-hidden
+            className="text-muted-foreground bg-muted hidden rounded px-1 font-mono text-[10px] leading-4 md:inline"
+          >
+            F
+          </kbd>
+        </button>
+      )}
+    </div>
   );
   if (coarse)
     return <div className="mb-2 flex justify-center select-none">{button}</div>;

package/components/Chat/TimelineRows.tsx

@@ -55,6 +55,7 @@ function Item({
       return (
         <UserTurn
           item={item}
+          onQuote={actions.onQuote}
           onUndo={
             item.checkpoint && actions.onUndo
               ? () => actions.onUndo?.(item.id)

package/components/Chat/composer/ComposerBody.tsx

@@ -32,6 +32,7 @@ import { offeredSuggestion } from "@/lib/chat/suggestion";
 import { historyStep } from "@/lib/chat/history";
 import { markdownParagraphs } from "@/lib/chat/quote";
 import { insertMarkdown } from "./insert";
+import { ForkHeader, type ForkComposer } from "./ForkHeader";
 import { useCoarsePointer } from "./useCoarsePointer";
 import { useMentions } from "./useMentions";
 import { Attachments } from "./Attachments";
@@ -52,6 +53,9 @@ export interface ComposerProps {
   running: boolean;
   disabled?: boolean;
   placeholder: string;
+  // The send button's label, when Enter does something else than send.
+  // Fork mode: the quote chip, pill and own-checkout choice.
+  fork?: ForkComposer;
   onSend: (text: string, images: ChatImage[], files: ChatFile[]) => void;
   // Where attached files are kept: the session's id, or "draft" before one exists.
   attachScope: string;
@@ -94,6 +98,7 @@ export function ComposerBody({
   running,
   disabled,
   placeholder,
+  fork,
   onSend,
   onStop,
   commands = [],
@@ -270,7 +275,11 @@ export function ComposerBody({
   const { dragging, dropProps, addFiles } = attach;
 
   const empty =
-    !text.trim() && !images.length && !files.length && !attach.uploads.length;
+    !fork?.quote &&
+    !text.trim() &&
+    !images.length &&
+    !files.length &&
+    !attach.uploads.length;
   const submit = () => {
     if (empty || disabled || attach.uploading) return;
     const used = leadingCommand(text)?.slice(1);
@@ -358,9 +367,10 @@ export function ComposerBody({
         {...dropProps}
         className={cn(
           "bg-card popover-surface rounded-2xl p-2 transition-shadow",
-          dragging && "ring-primary ring-2"
+          (dragging || fork) && "ring-primary ring-2"
         )}
       >
+        {fork && <ForkHeader fork={fork} />}
         <Attachments
           images={images}
           files={files}
@@ -393,6 +403,8 @@ export function ComposerBody({
           onStop={onStop}
           canSend={!disabled && !empty && !attach.uploading}
           onSend={submit}
+          sendLabel={fork ? "Start fork" : undefined}
+          fork={fork}
         />
       </div>
     </div>

package/components/Chat/composer/ForkHeader.tsx

@@ -0,0 +1,55 @@
+"use client";
+
+import { GitFork, Quote, X } from "lucide-react";
+
+export interface ForkComposer {
+  // The selection being forked; the instruction is this plus what's typed.
+  quote: string;
+  own: boolean;
+  onOwn: () => void;
+  onLeave: () => void;
+  onDropQuote: () => void;
+}
+
+// Top of the composer in Fork mode: the pill that marks it, what the keys do,
+// and the selection as a chip.
+export function ForkHeader({ fork }: { fork: ForkComposer }) {
+  return (
+    <div className="mb-1.5 space-y-1.5">
+      <div className="flex items-center gap-2">
+        <span className="bg-primary/10 text-primary flex h-8 items-center gap-1.5 rounded-lg pr-1 pl-2.5 text-xs font-medium">
+          <GitFork aria-hidden className="size-3.5" />
+          Fork
+          <button
+            type="button"
+            onMouseDown={(e) => e.preventDefault()}
+            onClick={fork.onLeave}
+            aria-label="Cancel fork"
+            className="hover:bg-primary/15 flex size-6 items-center justify-center rounded-md"
+          >
+            <X aria-hidden className="size-3.5" />
+          </button>
+        </span>
+        <span className="flex-1" />
+        <span className="text-muted-foreground hidden text-xs md:inline">
+          ↵ start · Esc cancel
+        </span>
+      </div>
+      {fork.quote && (
+        <div className="bg-muted/60 text-muted-foreground flex items-start gap-2 rounded-lg py-1.5 pr-1 pl-2.5 text-sm">
+          <Quote aria-hidden className="mt-1 size-3.5 shrink-0" />
+          <p className="line-clamp-2 min-w-0 flex-1">{fork.quote}</p>
+          <button
+            type="button"
+            onMouseDown={(e) => e.preventDefault()}
+            onClick={fork.onDropQuote}
+            aria-label="Remove quote"
+            className="hover:text-foreground flex size-8 shrink-0 items-center justify-center"
+          >
+            <X aria-hidden className="size-4" />
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}

package/components/Chat/composer/Toolbar.tsx

@@ -3,6 +3,8 @@
 import { useRef, useState } from "react";
 import {
   ArrowUp,
+  Folder,
+  GitFork,
   Paperclip,
   ListChecks,
   MonitorUp,
@@ -41,6 +43,8 @@ export function Toolbar({
   onStop,
   canSend,
   onSend,
+  sendLabel = "Send",
+  fork,
 }: {
   plain: boolean;
   onTogglePlain: () => void;
@@ -65,6 +69,9 @@ export function Toolbar({
   onStop: () => void;
   canSend: boolean;
   onSend: () => void;
+  sendLabel?: string;
+  // Fork mode: the own-checkout choice, and a send button that says what it does.
+  fork?: { own: boolean; onOwn: () => void };
 }) {
   const fileRef = useRef<HTMLInputElement>(null);
   const formatting = plain ? "Formatting off" : "Formatting on";
@@ -103,7 +110,7 @@ export function Toolbar({
           e.target.value = "";
         }}
       />
-      {canCapture && (
+      {canCapture && !fork && (
         <Button
           type="button"
           variant="ghost"
@@ -135,10 +142,28 @@ export function Toolbar({
           <span className={plan ? "" : "hidden sm:inline"}>Plan</span>
         </button>
       )}
-      {onSetAccess && access && (
+      {fork && (
+        <button
+          type="button"
+          aria-pressed={fork.own}
+          title="Own checkout lets the fork edit code; off, it reads this checkout and leaves it alone"
+          onMouseDown={(e) => e.preventDefault()}
+          onClick={fork.onOwn}
+          className={cn(
+            "flex h-10 shrink-0 items-center gap-1 rounded-lg px-2 text-xs",
+            fork.own
+              ? "bg-primary/10 text-primary"
+              : "text-muted-foreground hover:text-foreground hover:bg-foreground/[0.05]"
+          )}
+        >
+          <Folder className="h-3.5 w-3.5" />
+          {fork.own ? "Own checkout" : "Reads only"}
+        </button>
+      )}
+      {!fork && onSetAccess && access && (
         <AccessPicker access={access} onPick={onSetAccess} />
       )}
-      {onSetModel && (
+      {!fork && onSetModel && (
         <ModelPicker
           models={models}
           model={model}
@@ -150,7 +175,7 @@ export function Toolbar({
         />
       )}
       <span className="flex-1" />
-      {accessory}
+      {!fork && accessory}
       <Button
         type="button"
         variant="ghost"
@@ -183,14 +208,25 @@ export function Toolbar({
         <Button
           type="button"
           size="icon"
-          aria-label="Send"
-          className="h-10 w-10 shrink-0 rounded-xl"
+          aria-label={sendLabel}
+          title={sendLabel}
+          className={cn(
+            "h-10 shrink-0 rounded-xl",
+            fork ? "w-auto gap-1.5 px-3.5" : "w-10"
+          )}
           disabled={!canSend}
           // Tapping send mustn't blur the editor and drop the keyboard.
           onMouseDown={(e) => e.preventDefault()}
           onClick={onSend}
         >
-          <ArrowUp className="h-4 w-4" />
+          {fork ? (
+            <>
+              <GitFork className="h-3.5 w-3.5" />
+              Start fork
+            </>
+          ) : (
+            <ArrowUp className="h-4 w-4" />
+          )}
         </Button>
       )}
     </div>

package/components/Chat/quote-selection.ts

@@ -103,9 +103,13 @@ export interface Placement {
 
 // Where the floating button goes, kept inside the visible chat (`view`),
 // which ends above the composer. Null when the selection is scrolled out.
-export function placeQuote(sel: Box, view: Box, size = 48): Placement | null {
+export function placeQuote(
+  sel: Box,
+  view: Box,
+  size = 48,
+  half = 60
+): Placement | null {
   if (sel.bottom < view.top || sel.top > view.bottom) return null;
-  const half = 60;
   const mid = (sel.left + sel.right) / 2;
   const x = Math.min(Math.max(mid, view.left + half), view.right - half);
   if (sel.top - size >= view.top) return { x, y: sel.top, side: "above" };

package/content/whats-new.json

@@ -1945,6 +1945,14 @@
       "area": "Updates",
       "text": "Automatic updates no longer get stuck after the first one because of a file the build rewrites.",
       "url": "https://github.com/saadnvd1/agent-os/pull/555"
+    },
+    {
+      "id": 558,
+      "date": "2026-11-02",
+      "kind": "improved",
+      "area": "AgentOS",
+      "text": "Select text in a chat reply and tap Fork to hand it to a background copy of the session; its result comes back as a card.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/558"
     }
   ]
 }

package/data/fork/index.ts

@@ -53,7 +53,12 @@ export function useForkChildren(sessionId: string, enabled: boolean) {
 export function useStartForks(sessionId: string) {
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async (input: { instructions: string[]; worktree: boolean }) =>
+    mutationFn: async (input: {
+      instructions: string[];
+      worktree: boolean;
+      labels?: string[];
+      delivery?: "wake" | "next";
+    }) =>
       json<{ children: { id: string; n: number; label: string }[] }>(
         await fetch("/api/fork", {
           method: "POST",

package/lib/chat/commands.ts

@@ -83,21 +83,6 @@ export function withFresh(commands: ChatCommand[]): ChatCommand[] {
     : [FRESH_COMMAND, ...commands];
 }
 
-// AgentOS's own command when forks are on: opens the fork sheet.
-export const FORK_COMMAND: ChatCommand = {
-  name: "fork",
-  description: "Start background copies of this session",
-};
-
-export const isForkCommand = (text: string): boolean =>
-  text.trim().toLowerCase() === "/fork";
-
-export function withFork(commands: ChatCommand[]): ChatCommand[] {
-  return commands.some((c) => c.name === "fork")
-    ? commands
-    : [FORK_COMMAND, ...commands];
-}
-
 export interface MenuGroup {
   label: string;
   commands: ChatCommand[];

package/lib/chat/events.ts

@@ -106,6 +106,9 @@ export interface ChatOrigin {
   body?: string;
   // Lines of an event batch that are the reader's answers to asks.
   decided?: string[];
+  // A fork delivery: the parent and the children it carries, shown as result
+  // cards (lib/fork/deliver).
+  forks?: { parent: string; ids: string[] };
   // The tasks it is about, by name, set where the event is delivered.
   subjects?: { id: string; name: string }[];
   // Only Away mode's own lines: the turn it starts isn't anyone's activity

package/lib/fork/brief.ts

@@ -3,7 +3,7 @@
 import { FORK_LIMITS } from "./options";
 import type { ChildRow } from "./types";
 
-export const PARENT_BRIEF = `Forks: when you have independent side work, \`aos fork "<instruction>" ["<instruction>" …]\` starts that many background copies of you (up to ${FORK_LIMITS.maxPerFork}) that know what you know. It returns at once; you keep working. Their results arrive as a message when they finish, or after \`aos wait children --all|--any [--timeout 30m]\` (end your turn; you're woken with them). \`aos children\` lists them, \`aos children <n>\` shows a full result, \`aos cancel <n>|--all\` stops them. Children have your abilities and work in your checkout: tell one that has to edit code to \`--worktree\` (its own throwaway checkout). Fork only work that doesn't depend on your next step.`;
+export const PARENT_BRIEF = `Forks: when the user asks you to fork, or to do things in parallel in background copies, run \`aos fork "<instruction>" ...\` (one instruction per fork), keep working, and results arrive as a message. Also when you have independent side work, \`aos fork "<instruction>" ["<instruction>" …]\` starts that many background copies of you (up to ${FORK_LIMITS.maxPerFork}) that know what you know. It returns at once; you keep working. Their results arrive as a message when they finish, or after \`aos wait children --all|--any [--timeout 30m]\` (end your turn; you're woken with them). \`aos children\` lists them, \`aos children <n>\` shows a full result, \`aos cancel <n>|--all\` stops them. Children have your abilities and work in your checkout: tell one that has to edit code to \`--worktree\` (its own throwaway checkout). Fork only work that doesn't depend on your next step.`;
 
 export const CHILD_BRIEF = `You are a fork child: a background copy of another session, started to do one piece of work and report back. You have its abilities, not its checkout: don't change the parent's files, push, open a PR or fork. Put temp work (scripts, repros, notes) in $AOS_SCRATCH. Run builds and tests only through \`aos heavy -- <command>\`, which queues you with the other forks. To ask the parent something, \`aos send <parent> "<question>"\`; that doesn't finish you. When done, \`aos return "<result>"\` (first line: the answer in a sentence; then the detail; \`--failed\` if you couldn't do it). Your reply when you end your turn without it is used as the result, after a short wait.`;
 
@@ -41,7 +41,9 @@ const outcomeWord = (c: ChildRow) =>
     ? "failed"
     : c.outcome === "cancelled"
       ? "cancelled"
-      : "done";
+      : c.outcome === "empty"
+        ? "ended with no result"
+        : "done";
 
 // One delivery: every result in the batch, whole when short, else its
 // summary and the command that reads the rest.

package/lib/fork/deliver.ts

@@ -34,7 +34,12 @@ async function send(parentId: string, deliveryId: string, rows: ChildRow[]) {
     text,
     queue: true,
     from: "AgentOS",
-    origin: { kind: "event", label: "Forks", body },
+    origin: {
+      kind: "event",
+      label: "Forks",
+      body,
+      forks: { parent: parentId, ids: rows.map((c) => c.child_session_id) },
+    },
   });
   markDelivered(deliveryId);
 }

package/lib/fork/ledger.ts

@@ -176,6 +176,11 @@ export function summaryOf(text: string): string {
   return one.length <= max ? one : `${one.slice(0, max - 1)}…`;
 }
 
+// A result that says nothing: blank, or one bare flag (`--help`) a child took
+// for its answer. A quoted sentence that starts with dashes is still an answer.
+export const isNonAnswer = (text: string | null | undefined): boolean =>
+  !text?.trim() || /^--?[a-z][a-z-]*$/i.test(text.trim());
+
 export const capResult = (text: string): string =>
   text.length <= FORK_LIMITS.resultChars
     ? text

package/lib/fork/settle.ts

@@ -22,6 +22,7 @@ import {
   updateResult,
   childrenOf,
   findChild,
+  isNonAnswer,
   markDeliveredIds,
 } from "./ledger";
 import { FORK_LIMITS } from "./options";
@@ -120,7 +121,11 @@ export async function returnChild(
   if (!row) throw new Error("Only a fork child can return a result");
   const body = text.trim();
   if (!body) throw new Error('Give the result: aos return "<result>"');
-  const outcome: ChildOutcome = failed ? "failed" : "ok";
+  const outcome: ChildOutcome = failed
+    ? "failed"
+    : isNonAnswer(body)
+      ? "empty"
+      : "ok";
   if (
     await settleAndDeliver(childId, {
       outcome,
@@ -205,10 +210,9 @@ export async function lookAtChild(row: ChildRow, now: number): Promise<void> {
   // It asked its parent something and is waiting for the answer.
   if (openWaits().some((w) => w.waiter_id === row.child_session_id)) return;
   const reply = lastReply(row.child_session_id);
-  if (!reply) return;
   await settleAndDeliver(row.child_session_id, {
-    outcome: "ok",
-    summary: summaryOf(reply),
+    outcome: isNonAnswer(reply) ? "empty" : "ok",
+    summary: reply ? summaryOf(reply) : "ended without a result",
     result: reply,
     kind: "implicit",
   });

package/lib/fork/types.ts

@@ -1,7 +1,9 @@
 export type ChildState =
   "queued" | "starting" | "running" | "needs_input" | "settled";
 
-export type ChildOutcome = "ok" | "failed" | "cancelled";
+// `empty`: it ended, but with nothing to read (blank, or a bare flag like
+// "--help"), so it isn't shown as a finished answer.
+export type ChildOutcome = "ok" | "failed" | "cancelled" | "empty";
 
 // `implicit`: the child's turn ended without `aos return`, so its final
 // answer stands in (kept apart so stats can tell them).
@@ -59,6 +61,8 @@ export interface ChildView {
   hold: string | null;
   outcome: ChildOutcome | null;
   summary: string | null;
+  // The start of its result, for the card in the parent's chat.
+  excerpt: string | null;
   resultKind: ResultKind | null;
   worktree: boolean;
   fellBack: boolean;

package/lib/fork/view.ts

@@ -13,6 +13,7 @@ export const childView = (c: ChildRow): ChildView => ({
   hold: c.hold,
   outcome: c.outcome,
   summary: c.summary,
+  excerpt: c.result ? c.result.slice(0, 600) : null,
   resultKind: c.result_kind,
   worktree: !!c.worktree,
   fellBack: !!c.fell_back,
@@ -61,6 +62,7 @@ export interface ForkStats {
   ok: number;
   failed: number;
   cancelled: number;
+  empty: number;
   implicit: number;
   fellBack: number;
   medianSeconds: number | null;
@@ -83,6 +85,7 @@ export function statsOf(rows: ChildRow[]): ForkStats {
     ok: done.filter((c) => c.outcome === "ok").length,
     failed: done.filter((c) => c.outcome === "failed").length,
     cancelled: done.filter((c) => c.outcome === "cancelled").length,
+    empty: done.filter((c) => c.outcome === "empty").length,
     implicit: done.filter(
       (c) => c.result_kind === "implicit" && c.outcome === "ok"
     ).length,
@@ -106,7 +109,7 @@ export function statsText(s: ForkStats): string {
   const pct = (n: number) =>
     s.settled ? `${Math.round((n / s.settled) * 100)}%` : "-";
   return [
-    `${s.children} children, ${s.settled} settled (${s.ok} ok, ${s.failed} failed, ${s.cancelled} cancelled)`,
+    `${s.children} children, ${s.settled} settled (${s.ok} ok, ${s.failed} failed, ${s.cancelled} cancelled, ${s.empty} no result)`,
     `returned without aos return: ${s.implicit} (${pct(s.implicit)}); started from a brief, not a fork: ${s.fellBack}`,
     `median time to settle: ${s.medianSeconds ?? "-"}s`,
     `tokens: ${s.tokensIn} in, ${s.tokensOut} out, ${s.cacheRead} cache read`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.828",
+  "version": "0.3.833",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/scripts/lib/build-swap.sh

@@ -8,7 +8,7 @@
 # Sourced by scripts/redeploy; run from the repository root.
 
 # shellcheck source=generated.sh
-source scripts/lib/generated.sh
+source "$(dirname "${BASH_SOURCE[0]}")/generated.sh"
 
 LIVE=.next
 NEXT_BUILD=.next-build

package/scripts/update-e2e.test.ts

@@ -19,6 +19,8 @@ const SCRIPTS = [
   "lib/build-swap.sh",
   "lib/pnpm.sh",
   "lib/deps-swap.sh",
+  "lib/generated.sh",
+  "generated-files.txt",
   "lib/update-verify.mjs",
 ];