@saadnvd1/agent-os 0.3.821 → 0.3.825

package/app/api/fork/cancel/route.ts

@@ -0,0 +1,19 @@
+import { NextRequest, NextResponse } from "next/server";
+import { fail, text } from "@/lib/fork/api";
+import { cancelChildren } from "@/lib/fork/settle";
+
+// Cancels one child (`ref`: its number, label or id) or all of a session's.
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const parent = text(body.from) ?? text(body.session);
+    if (!parent) throw new Error("Which session's forks?");
+    const ref = text(body.ref) ?? undefined;
+    if (!ref && body.all !== true)
+      throw new Error("Which fork, or all of them?");
+    const done = await cancelChildren(parent, ref);
+    return NextResponse.json({ cancelled: done.map((c) => c.label) });
+  } catch (error) {
+    return fail(error);
+  }
+}

package/app/api/fork/children/route.ts

@@ -0,0 +1,52 @@
+import { NextRequest, NextResponse } from "next/server";
+import { fail } from "@/lib/fork/api";
+import { db } from "@/lib/db";
+import { allChildren, childrenOf, getChild, numberOf } from "@/lib/fork/ledger";
+import { childrenView, statsOf, statsText } from "@/lib/fork/view";
+import { forksOn } from "@/lib/fork/options";
+
+// A session's forks, for `aos children` and the chat's strip. `stats` adds
+// the numbers; with no session, the totals over every fork.
+export async function GET(request: NextRequest) {
+  try {
+    const params = request.nextUrl.searchParams;
+    const session = params.get("session");
+    if (!session && params.get("stats") !== "1")
+      throw new Error("Which session?");
+    if (!session) {
+      const { db } = await import("@/lib/db");
+      const rows = db
+        .prepare(`SELECT * FROM session_children`)
+        .all() as Parameters<typeof statsOf>[0];
+      const stats = statsOf(rows);
+      return NextResponse.json({ stats, text: statsText(stats) });
+    }
+    const view = childrenView(session);
+    const own = getChild(session);
+    const asChild = own
+      ? {
+          parentId: own.parent_session_id,
+          parentName:
+            (
+              db
+                .prepare(`SELECT name FROM sessions WHERE id = ?`)
+                .get(own.parent_session_id) as { name: string } | undefined
+            )?.name ?? "its session",
+          n: numberOf(own.parent_session_id, session),
+          label: own.label,
+          state: own.state,
+          worktree: !!own.worktree,
+        }
+      : null;
+    const rows = childrenOf(session);
+    const stats = params.get("stats") === "1" ? statsOf(rows) : undefined;
+    return NextResponse.json({
+      enabled: forksOn(),
+      asChild,
+      ...view,
+      ...(stats && { stats, text: statsText(stats) }),
+    });
+  } catch (error) {
+    return fail(error);
+  }
+}

package/app/api/fork/result/route.ts

@@ -0,0 +1,29 @@
+import { NextRequest, NextResponse } from "next/server";
+import { fail, text } from "@/lib/fork/api";
+import { findChild, markUsed, numberOf } from "@/lib/fork/ledger";
+
+// One child's whole result (`aos children <n>`); reading it counts as
+// opening it, for the stats.
+export async function GET(request: NextRequest) {
+  try {
+    const params = request.nextUrl.searchParams;
+    const parent = text(params.get("session"));
+    const ref = text(params.get("ref"));
+    if (!parent || !ref) throw new Error("session and ref are required");
+    const c = findChild(parent, ref);
+    markUsed(c.child_session_id, "opened");
+    return NextResponse.json({
+      id: c.child_session_id,
+      n: numberOf(parent, c.child_session_id),
+      label: c.label,
+      state: c.state,
+      outcome: c.outcome,
+      kind: c.result_kind,
+      summary: c.summary,
+      result: c.result,
+      instruction: c.instruction,
+    });
+  } catch (error) {
+    return fail(error);
+  }
+}

package/app/api/fork/return/route.ts

@@ -0,0 +1,20 @@
+import { NextRequest, NextResponse } from "next/server";
+import { fail, text } from "@/lib/fork/api";
+import { returnChild } from "@/lib/fork/settle";
+
+// `aos return`: a fork child hands in its result.
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const child = text(body.from);
+    if (!child) throw new Error("Only a fork child can return a result");
+    const state = await returnChild(
+      child,
+      String(body.text ?? ""),
+      body.failed === true
+    );
+    return NextResponse.json({ state });
+  } catch (error) {
+    return fail(error);
+  }
+}

package/app/api/fork/route.ts

@@ -0,0 +1,32 @@
+import { NextRequest, NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+import { fail, text } from "@/lib/fork/api";
+import { startFork } from "@/lib/fork/start";
+import { DELIVERY_MODES } from "@/lib/fork/options";
+
+// Starts forks of a session: `from` is the session asking (an agent's `aos
+// fork`); a person's tap names it as `session`.
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const agent = text(body.from);
+    const parentId = agent ?? text(body.session);
+    if (!parentId) throw new Error("Which session to fork?");
+    const instructions = Array.isArray(body.instructions)
+      ? body.instructions.filter((t: unknown) => typeof t === "string")
+      : [];
+    const delivery = DELIVERY_MODES.find((d) => d === body.delivery);
+    const started = startFork({
+      parentId,
+      requestId: text(body.requestId) ?? randomUUID(),
+      instructions,
+      labels: Array.isArray(body.labels) ? body.labels : undefined,
+      worktree: body.worktree === true,
+      startedBy: agent ? "agent" : "user",
+      delivery,
+    });
+    return NextResponse.json(started, { status: started.repeat ? 200 : 201 });
+  } catch (error) {
+    return fail(error);
+  }
+}

package/app/api/fork/wait/route.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from "next/server";
+import { fail, text } from "@/lib/fork/api";
+import { FORKS_OFF, forksOn } from "@/lib/fork/options";
+import { registerForkWait } from "@/lib/fork/waits";
+import { parseTimeout } from "@/lib/bus/waits/register";
+import { kickForks } from "@/lib/fork/tick";
+
+// `aos wait children --all|--any [--timeout 30m]`: records the wait and
+// returns; the parent is woken with the results.
+export async function POST(request: NextRequest) {
+  try {
+    if (!forksOn()) throw new Error(FORKS_OFF);
+    const body = await request.json();
+    const parent = text(body.from);
+    if (!parent) throw new Error("Only a session can wait on its forks");
+    const mode = body.mode === "any" ? "any" : "all";
+    const r = registerForkWait(
+      parent,
+      mode,
+      parseTimeout(body.timeout == null ? null : String(body.timeout))
+    );
+    kickForks();
+    return NextResponse.json(r);
+  } catch (error) {
+    return fail(error);
+  }
+}

package/app/api/load/heavy/lease/route.ts

@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from "next/server";
+import { isChild } from "@/lib/fork/ledger";
+import { releaseLease, requestLease } from "@/lib/fork/heavy-lease";
+
+// A fork child's `aos heavy` asks for a slot here and waits its turn; any
+// other session isn't queued (it only gets the advice in /api/load/heavy).
+export async function POST(request: NextRequest) {
+  try {
+    const { session, pid, action = "request" } = await request.json();
+    if (typeof session !== "string" || !Number.isInteger(pid) || pid <= 0)
+      return NextResponse.json(
+        { error: "session and pid are required" },
+        { status: 400 }
+      );
+    if (!isChild(session))
+      return NextResponse.json({ granted: true, ahead: 0 });
+    if (action === "release") {
+      releaseLease(session, pid);
+      return NextResponse.json({ released: true });
+    }
+    return NextResponse.json(requestLease(session, pid));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

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

@@ -1,17 +1,30 @@
 import { NextResponse } from "next/server";
-import { archiveChecked } from "@/lib/done/archive";
+import { archiveChecked, ForkChildrenOpen } from "@/lib/done/archive";
 
 // POST /api/sessions/:id/archive - put a session away, out of the sidebar.
 // 409 with the reason when refused.
 export async function POST(
-  _request: Request,
+  request: Request,
   { params }: { params: Promise<{ id: string }> }
 ) {
   try {
-    const session = await archiveChecked((await params).id);
+    const body = (await request.json().catch(() => ({}))) as {
+      children?: unknown;
+    };
+    const children =
+      body.children === "stop" || body.children === "keep"
+        ? body.children
+        : undefined;
+    const session = await archiveChecked((await params).id, { children });
     return NextResponse.json({ session });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    return NextResponse.json({ error: message }, { status: 409 });
+    return NextResponse.json(
+      {
+        error: message,
+        ...(error instanceof ForkChildrenOpen && { children: error.open }),
+      },
+      { status: 409 }
+    );
   }
 }

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

@@ -9,7 +9,6 @@ import {
 } from "@/lib/worktrees";
 import { releasePort } from "@/lib/ports";
 import { releaseSessionLeftovers } from "@/lib/sessions/leftovers";
-import { killWorker } from "@/lib/orchestration";
 import { endSessionAgent } from "@/lib/sessions/end";
 import { endTmuxSession } from "@/lib/tmux/end";
 import { hostExecFile } from "@/lib/hosts";
@@ -264,11 +263,11 @@ export async function DELETE(request: NextRequest, { params }: RouteParams) {
       );
     }
 
-    // If this is a conductor, delete all its workers first
+    // Children nested under this session go with it
     const workers = queries.getWorkersByConductor(db).all(id) as Session[];
     for (const worker of workers) {
       try {
-        await killWorker(worker.id, false); // false = don't cleanup worktree yet
+        await endSessionAgent(worker);
       } catch (error) {
         console.error(`Failed to kill worker ${worker.id}:`, error);
       }

package/app/page.tsx

@@ -318,11 +318,6 @@ function HomeContent() {
         return { sessionName, cwd, hostId, sessionId };
       }
 
-      // TODO: Add explicit "Enable Orchestration" toggle that creates .mcp.json
-      // for conductor sessions. Removed auto-creation because it pollutes projects
-      // with .mcp.json files that aren't in their .gitignore.
-      // See: /api/sessions/[id]/mcp-config, lib/mcp-config.ts
-
       // Get parent session ID for forking
       let parentSessionId: string | null = null;
       if (!session.claude_session_id && isFork(session)) {

package/components/Chat/ChatPanel.tsx

@@ -1,9 +1,6 @@
 "use client";
 
-import type { StepCounts } from "@/lib/chat/tool-outcome";
 import {
-  Fragment,
-  memo,
   useCallback,
   useEffect,
   useLayoutEffect,
@@ -15,14 +12,17 @@ import { ArrowDown, Loader2 } from "lucide-react";
 import type { ClipboardEvent } from "react";
 import { useChat } from "@/data/chat/useChat";
 import { PausedBanner } from "./PausedBanner";
+import { groupTimeline } from "@/lib/chat/group";
+import type { ChatItem } from "@/lib/chat/events";
 import {
-  groupTimeline,
-  sameBlock,
-  STANDALONE_TOOLS,
-  type TimelineBlock,
-} from "@/lib/chat/group";
-import type { ApprovalDecision, ChatItem } from "@/lib/chat/events";
-import { isFreshCommand, withFresh } from "@/lib/chat/commands";
+  isForkCommand,
+  isFreshCommand,
+  withFork,
+  withFresh,
+} from "@/lib/chat/commands";
+import { useExperiment } from "@/data/experiments";
+import { ForkDialog, ForksStrip } from "./Forks";
+import { ReplyingTo } from "./ReplyingTo";
 import { compactsFirst } from "@/lib/chat/pending";
 import { useFreshStart } from "@/data/sessions";
 import {
@@ -35,10 +35,8 @@ import { quoteInsert, quoteMarkdown } from "@/lib/chat/quote";
 import { OrchestratorBar } from "@/components/Orchestrator/OrchestratorBar";
 import { ActivityLine } from "./Activity";
 import { modelLabel as pickedModelLabel } from "./ModelPicker";
-import { Approval } from "./Approval";
 import { BackgroundTasks } from "./BackgroundTasks";
-import { SubagentCard } from "./Subagent";
-import { UndoDialog, UndoneBlock } from "./Undo";
+import { UndoDialog } from "./Undo";
 import { Composer } from "./Composer";
 import { Queue } from "./Queue";
 import { LivePanel } from "@/components/Live/LivePanel";
@@ -48,25 +46,19 @@ import { composerCompacts } from "@/lib/chat/stale";
 import { useFreshStartQuery } from "@/data/fresh-start";
 import { QuoteButton } from "./QuoteButton";
 import { quoteIntoComposer } from "./quote-selection";
-import { ToolBodies, ToolGroup } from "./Tools";
+import { ToolBodies } from "./Tools";
 import { RowState, RowStore } from "./rowState";
 import { useKeybindings } from "@/hooks/useKeybindings";
 import { Background, type BackgroundValue } from "./background";
 import { FindBar } from "./FindBar";
 import { useFind, useFindShortcut } from "./useFind";
-import { McpServers } from "./McpServers";
 import { ChatSessionId } from "./session";
-import { ArtifactCard } from "./Artifact";
-import { PlanCard } from "./PlanCard";
 import { ChatIdle, RetryTurn } from "./idle";
 import { RETRY_TEXT } from "@/lib/chat/turn-end";
 import { ContextMeter } from "./ContextMeter";
 import { SetupCard } from "./SetupCard";
-import { UserTurn } from "./EventRow";
-import { EventGroup } from "./EventTurns";
 import { needsMoreHistory } from "./needs-more-history";
 import { useGoToItem } from "./useGoToItem";
-import { NewDivider } from "./NewDivider";
 import { usePosition } from "./usePosition";
 import { NeedsYouStrip } from "@/components/Orchestrator/NeedsYouStrip";
 import { useResolveQuestion } from "@/data/orchestrators";
@@ -83,180 +75,12 @@ import {
   TurnStarts,
   type BookmarkChat,
 } from "@/components/Bookmarks/context";
-import {
-  AssistantMessage,
-  CommandOutput,
-  Compacted,
-  SkillChip,
-  UserMessage,
-  ErrorMessage,
-  NoteLine,
-  Reasoning,
-  Todos,
-  TurnEnd,
-} from "./Messages";
-
-interface ItemActions {
-  respond: (id: string, answer: ApprovalDecision) => void;
-  // Absent inside undone messages; hidden while the agent works (ChatIdle).
-  onCarryPlan?: (id: string) => void;
-  onKeepPlanning?: () => void;
-  // Absent inside undone messages; hidden while the agent works (ChatIdle).
-  onUndo?: (id: string) => void;
-  onQuote?: (text: string) => void;
-}
-
-function Item({
-  item,
-  actions,
-  steps,
-}: {
-  item: ChatItem;
-  actions: ItemActions;
-  steps?: StepCounts;
-}) {
-  switch (item.kind) {
-    case "user":
-      return (
-        <UserTurn
-          item={item}
-          onUndo={
-            item.checkpoint && actions.onUndo
-              ? () => actions.onUndo?.(item.id)
-              : undefined
-          }
-        />
-      );
-    case "assistant":
-      return <AssistantMessage item={item} onQuote={actions.onQuote} />;
-    case "reasoning":
-      return <Reasoning item={item} />;
-    case "todos":
-      return <Todos item={item} />;
-    case "turn_end":
-      return <TurnEnd item={item} steps={steps} />;
-    case "error":
-      return <ErrorMessage item={item} />;
-    case "command_output":
-      return <CommandOutput item={item} />;
-    case "mcp":
-      return <McpServers item={item} />;
-    case "compacted":
-      return <Compacted item={item} />;
-    case "note":
-      return <NoteLine item={item} />;
-    case "artifact":
-      return <ArtifactCard item={item} />;
-    case "approval":
-      return <Approval item={item} respond={actions.respond} />;
-    case "plan":
-      return (
-        <PlanCard
-          item={item}
-          onCarryOut={
-            actions.onCarryPlan
-              ? () => actions.onCarryPlan?.(item.id)
-              : undefined
-          }
-          onKeepPlanning={() => actions.onKeepPlanning?.()}
-        />
-      );
-    case "tool":
-      return item.name === "Skill" ? (
-        <SkillChip item={item} />
-      ) : STANDALONE_TOOLS.has(item.name) ? (
-        <SubagentCard item={item} />
-      ) : null;
-    default:
-      return null;
-  }
-}
-
-function Timeline({
-  blocks,
-  actions,
-}: {
-  blocks: TimelineBlock[];
-  actions: ItemActions;
-}) {
-  return blocks.map((b) => (
-    <Block
-      key={b.type === "item" ? b.item.id : b.id}
-      block={b}
-      actions={actions}
-    />
-  ));
-}
-
-const blockKey = (b: TimelineBlock) => (b.type === "item" ? b.item.id : b.id);
+import { UserMessage } from "./Messages";
 
-// One block, re-rendered only when its items or the actions change: a long
-// conversation doesn't redraw every message for each streamed word.
-const Block = memo(
-  function Block({
-    block: b,
-    actions,
-  }: {
-    block: TimelineBlock;
-    actions: ItemActions;
-  }) {
-    const respond = actions.respond;
-    const undoneActions = useMemo(
-      () => ({ respond, onQuote: actions.onQuote }),
-      [respond, actions.onQuote]
-    );
-    return b.type === "tools" ? (
-      <ToolGroup tools={b.tools} />
-    ) : b.type === "events" ? (
-      <EventGroup
-        id={b.id}
-        turns={b.turns}
-        renderReplies={(items) => (
-          <Timeline blocks={groupTimeline(items)} actions={undoneActions} />
-        )}
-      />
-    ) : b.type === "undone" ? (
-      <UndoneBlock
-        undo={b.undo}
-        count={b.items.filter((i) => i.kind === "user").length}
-      >
-        <Timeline blocks={groupTimeline(b.items)} actions={undoneActions} />
-      </UndoneBlock>
-    ) : (
-      <div data-item={b.item.id}>
-        <Item item={b.item} actions={actions} steps={b.steps} />
-      </div>
-    );
-  },
-  (prev, next) =>
-    prev.actions === next.actions && sameBlock(prev.block, next.block)
-);
+import type { ItemActions } from "./TimelineRows";
+import { TimelineRows } from "./TimelineRows";
 
-// The conversation's rows in the page's flow, not a virtualized list: a
-// selection follows the DOM, and a list that recycles and re-orders its rows
-// breaks it (docs/decisions/2026-10-11-chat-timeline-in-flow.md).
-export function TimelineRows({
-  blocks,
-  actions,
-  newFrom,
-}: {
-  blocks: TimelineBlock[];
-  actions: ItemActions;
-  // The block the reader hasn't seen yet begins at, when they were away.
-  newFrom?: string | null;
-}) {
-  return blocks.map((b) => (
-    <Fragment key={blockKey(b)}>
-      {newFrom === blockKey(b) && <NewDivider />}
-      <div
-        data-block={blockKey(b)}
-        className="chat-row mx-auto w-full max-w-3xl px-4 pb-4"
-      >
-        <Block block={b} actions={actions} />
-      </div>
-    </Fragment>
-  ));
-}
+export { TimelineRows };
 
 export function ChatPanel({
   sessionId,
@@ -282,6 +106,9 @@ export function ChatPanel({
     at: number;
     append?: boolean;
   }>();
+  const forksOn = useExperiment("forks");
+  const [forkOpen, setForkOpen] = useState(false);
+  const withForkIf = (c: typeof commands) => (forksOn ? withFork(c) : c);
   const {
     items,
     hasMore,
@@ -799,19 +626,7 @@ export function ChatPanel({
           />
         )}
         {replyTo && (
-          <div className="text-muted-foreground mb-2 flex min-h-11 items-center gap-2 rounded-lg px-2 text-xs">
-            <span className="min-w-0 flex-1 truncate">
-              Answering: {replyTo.text}
-            </span>
-            <button
-              type="button"
-              onClick={() => setReplyTo(null)}
-              aria-label="Stop answering"
-              className="hover:text-foreground flex size-11 shrink-0 items-center justify-center"
-            >
-              ×
-            </button>
-          </div>
+          <ReplyingTo text={replyTo.text} onStop={() => setReplyTo(null)} />
         )}
         <ActivityLine
           items={items}
@@ -830,6 +645,7 @@ export function ChatPanel({
         />
         <QuoteButton rootRef={scrollRef} onQuote={quote} />
         <PausedBanner sessionId={sessionId} />
+        <ForksStrip sessionId={sessionId} />
         <Queue
           queue={queue}
           running={running}
@@ -872,6 +688,10 @@ export function ChatPanel({
               startFresh.mutate(sessionId);
               return;
             }
+            if (forksOn && isForkCommand(text)) {
+              setForkOpen(true);
+              return;
+            }
             toEnd();
             const compact = composerCompacts(text, context, {
               state,
@@ -891,7 +711,7 @@ export function ChatPanel({
             }
           }}
           onStop={interrupt}
-          commands={freshStart ? withFresh(commands) : commands}
+          commands={withForkIf(freshStart ? withFresh(commands) : commands)}
           onRefreshCommands={refreshCommands}
           refreshingCommands={refreshingCommands}
           models={models}
@@ -911,6 +731,13 @@ export function ChatPanel({
           focusKey={active ? sessionId : null}
         />
       </div>
+      {forksOn && (
+        <ForkDialog
+          sessionId={sessionId}
+          open={forkOpen}
+          onOpenChange={setForkOpen}
+        />
+      )}
       {undoPreview && (
         <UndoDialog
           preview={undoPreview.preview}