@saadnvd1/agent-os 0.3.824 → 0.3.826

package/components/Pane/index.tsx

@@ -14,7 +14,6 @@ import type { TerminalHandle } from "@/components/Terminal";
 import type { Session, Project } from "@/lib/db";
 import { sessionRegistry } from "@/lib/client/session-registry";
 import { cn } from "@/lib/utils";
-import { ConductorPanel } from "@/components/ConductorPanel";
 import { useFileEditor } from "@/hooks/useFileEditor";
 import { MobileTabBar } from "./MobileTabBar";
 import { PairSwitch } from "@/components/Analyst/PairSwitch";
@@ -208,14 +207,6 @@ export const Pane = memo(function Pane({
   // File editor state - lifted here so it persists across view switches
   const fileEditor = useFileEditor();
 
-  // Check if this session is a conductor (has workers)
-  const workerCount = useMemo(() => {
-    if (!session) return 0;
-    return sessions.filter((s) => s.conductor_session_id === session.id).length;
-  }, [session, sessions]);
-
-  const isConductor = workerCount > 0;
-
   // A merged task keeps the log AgentOS wrote of it.
   const merged =
     !!session &&
@@ -477,10 +468,8 @@ export const Pane = memo(function Pane({
           sessions={sessions}
           projects={projects}
           viewMode={viewMode}
-          isConductor={isConductor}
           hasLog={hasLog}
           hasReport={hasReport}
-          workerCount={workerCount}
           showGit={showGit}
           onMenuClick={onMenuClick}
           onViewModeChange={setViewMode}
@@ -501,10 +490,8 @@ export const Pane = memo(function Pane({
           sessions={sessions}
           viewMode={viewMode}
           isFocused={isFocused}
-          isConductor={isConductor}
           hasLog={hasLog}
           hasReport={hasReport}
-          workerCount={workerCount}
           canSplit={canSplit}
           canClose={canClose}
           hasAttachedTmux={!!activeTab?.attachedTmux}
@@ -587,24 +574,6 @@ export const Pane = memo(function Pane({
               onOpenInFiles={isLocalSession ? openInFiles : undefined}
             />
           )}
-
-          {/* Workers */}
-          {viewMode === "workers" && session && (
-            <ConductorPanel
-              conductorSessionId={session.id}
-              onAttachToWorker={(workerId) => {
-                setViewMode("terminal");
-                const worker = sessions.find((s) => s.id === workerId);
-                if (worker && terminalRef) {
-                  terminalRef.attach({
-                    sessionName: worker.tmux_name || `claude-${workerId}`,
-                    hostId: worker.host_id,
-                    attachOnly: true,
-                  });
-                }
-              }}
-            />
-          )}
         </div>
       ) : (
         <ResizablePanelGroup
@@ -663,25 +632,6 @@ export const Pane = memo(function Pane({
                       onOpenInFiles={isLocalSession ? openInFiles : undefined}
                     />
                   )}
-
-                  {/* Workers */}
-                  {viewMode === "workers" && session && (
-                    <ConductorPanel
-                      conductorSessionId={session.id}
-                      onAttachToWorker={(workerId) => {
-                        setViewMode("terminal");
-                        const worker = sessions.find((s) => s.id === workerId);
-                        if (worker && terminalRef) {
-                          terminalRef.attach({
-                            sessionName:
-                              worker.tmux_name || `claude-${workerId}`,
-                            hostId: worker.host_id,
-                            attachOnly: true,
-                          });
-                        }
-                      }}
-                    />
-                  )}
                 </div>
               </ResizablePanel>
 

package/components/SessionList/useDoneAction.ts

@@ -1,6 +1,7 @@
 import { toast } from "sonner";
 import type { Session } from "@/lib/db";
 import {
+  ForkChildrenOpenError,
   useArchiveSession,
   useDoneSession,
   useResurrectSession,
@@ -57,8 +58,8 @@ export function useDoneAction() {
 export function useArchiveAction() {
   const archive = useArchiveSession();
   const unarchive = useUnarchiveSession();
-  return (session: Session) =>
-    archive.mutate(session.id, {
+  const run = (session: Session, children?: "stop" | "keep") =>
+    archive.mutate(children ? { id: session.id, children } : session.id, {
       onSuccess: () =>
         toast.success(`Archived ${session.name}`, {
           action: {
@@ -66,8 +67,22 @@ export function useArchiveAction() {
             onClick: () => unarchive.mutate(session.id),
           },
         }),
-      onError: (e) => toast.error(e.message, { duration: 12000 }),
+      onError: (e) =>
+        e instanceof ForkChildrenOpenError
+          ? toast(e.message, {
+              duration: 15000,
+              action: {
+                label: "Stop them",
+                onClick: () => run(session, "stop"),
+              },
+              cancel: {
+                label: "Keep them going",
+                onClick: () => run(session, "keep"),
+              },
+            })
+          : toast.error(e.message, { duration: 12000 }),
     });
+  return (session: Session) => run(session);
 }
 
 // Restore from a session's menu: the same conversation, its worktree back.

package/contexts/PaneContext.tsx

@@ -29,7 +29,7 @@ import {
 import { useViewport } from "@/hooks/useViewport";
 
 export type ViewMode =
-  "terminal" | "files" | "git" | "workers" | "log" | "artifacts" | "report";
+  "terminal" | "files" | "git" | "log" | "artifacts" | "report";
 
 export interface PaneViewState {
   viewMode: ViewMode;

package/data/done/index.ts

@@ -73,9 +73,33 @@ export function useDoneSession() {
   );
 }
 
+// Archiving a session whose forks are still running asks what to do with them.
+export class ForkChildrenOpenError extends Error {
+  constructor(
+    message: string,
+    readonly open: number
+  ) {
+    super(message);
+  }
+}
+
 export function useArchiveSession() {
-  return useDoneMutation(async (id: string) =>
-    json(await post(`/api/sessions/${id}/archive`))
+  return useDoneMutation(
+    async (input: string | { id: string; children: "stop" | "keep" }) => {
+      const { id, children } =
+        typeof input === "string" ? { id: input, children: undefined } : input;
+      const res = await post(
+        `/api/sessions/${id}/archive`,
+        children ? { children } : undefined
+      );
+      const data = await res
+        .clone()
+        .json()
+        .catch(() => null);
+      if (res.status === 409 && typeof data?.children === "number")
+        throw new ForkChildrenOpenError(data.error, data.children);
+      return json(res);
+    }
   );
 }
 

package/data/fork/index.ts

@@ -0,0 +1,83 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { ChildView, GroupView } from "@/lib/fork/types";
+
+export type { ChildView, GroupView };
+
+export interface ForkChildrenView {
+  enabled: boolean;
+  // Set when this session is itself a fork child.
+  asChild: {
+    parentId: string;
+    parentName: string;
+    n: number;
+    label: string;
+    state: ChildView["state"];
+    worktree: boolean;
+  } | null;
+  children: ChildView[];
+  groups: GroupView[];
+}
+
+export const forkKeys = {
+  all: ["forks"] as const,
+  children: (sessionId: string) => ["forks", "children", sessionId] as const,
+};
+
+async function json<T>(res: Response): Promise<T> {
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || "Request failed");
+  return data;
+}
+
+// A session's forks. Only asked while the experiment is on; refetched
+// every few seconds while any is still going (results land by themselves).
+export function useForkChildren(sessionId: string, enabled: boolean) {
+  return useQuery({
+    queryKey: forkKeys.children(sessionId),
+    queryFn: async () =>
+      json<ForkChildrenView>(
+        await fetch(
+          `/api/fork/children?session=${encodeURIComponent(sessionId)}`
+        )
+      ),
+    enabled,
+    staleTime: 2_000,
+    refetchInterval: (q) =>
+      q.state.data?.children.some((c) => c.state !== "settled") ||
+      q.state.data?.asChild
+        ? 4_000
+        : false,
+  });
+}
+
+export function useStartForks(sessionId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input: { instructions: string[]; worktree: boolean }) =>
+      json<{ children: { id: string; n: number; label: string }[] }>(
+        await fetch("/api/fork", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ session: sessionId, ...input }),
+        })
+      ),
+    onSuccess: () =>
+      queryClient.invalidateQueries({ queryKey: forkKeys.children(sessionId) }),
+  });
+}
+
+export function useCancelForks(sessionId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input: { ref?: string; all?: boolean }) =>
+      json<{ cancelled: string[] }>(
+        await fetch("/api/fork/cancel", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ session: sessionId, ...input }),
+        })
+      ),
+    onSuccess: () =>
+      queryClient.invalidateQueries({ queryKey: forkKeys.children(sessionId) }),
+  });
+}

package/lib/chat/commands.ts

@@ -83,6 +83,21 @@ 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/runner.ts

@@ -87,6 +87,7 @@ import { chatHold, chatRefusal } from "./hold";
 import { getHost } from "../hosts";
 import { hostLink } from "../hosts/remote-api";
 import { ownerUi } from "../owner";
+import { heldForNext } from "../fork/held";
 
 export {
   refreshCapabilities,
@@ -432,10 +433,15 @@ export async function sendChat(
     id?: string;
   } & SentBy
 ): Promise<void> {
-  const text = input.text.trim();
-  if (!text && !input.images?.length && !input.files?.length) return;
+  const typed = input.text.trim();
+  if (!typed && !input.images?.length && !input.files?.length) return;
   if (input.id && taken(sessionId, input.id)) return;
   refuseAway(sessionId);
+  // Results of forks the reader started come first in their next message.
+  const text =
+    !input.from && !input.origin && !input.peer
+      ? heldForNext(sessionId) + typed
+      : typed;
   const id = input.id ?? `user-${Date.now()}-${randomUUID().slice(0, 5)}`;
   // Its worktree is still being set up, its task hasn't launched (held by
   // Pause, say), or it's moving or landing: the message waits its turn.

package/lib/chat/worker/extras.ts

@@ -2,6 +2,7 @@ import type { Session } from "../../db";
 import type { ChatStartOptions } from "../driver";
 import { refreshSettings } from "../refresh";
 import { sessionProviderEnv } from "../../models/launch";
+import { childExtras } from "../../fork/extras";
 
 export type RoleExtras = Pick<
   ChatStartOptions,
@@ -30,7 +31,12 @@ export async function roleExtras(session: Session): Promise<RoleExtras> {
     ownExtras(session),
     sessionProviderEnv(session),
   ]);
-  return env ? { ...extras, env } : extras;
+  const fork = childExtras(session);
+  return {
+    ...extras,
+    ...(fork?.toolGuard && { toolGuard: fork.toolGuard }),
+    ...((env || fork) && { env: { ...env, ...fork?.env } }),
+  };
 }
 
 async function ownExtras(session: Session): Promise<RoleExtras> {

package/lib/chat/worker/host.ts

@@ -7,6 +7,7 @@
 import os from "os";
 import { db, type Session } from "../../db";
 import { agentEnv } from "../../agents/launch";
+import { forkBrief } from "../../fork/extras";
 import { sessionRunningBrief } from "../../project-config/session";
 import { BUS_BRIEF } from "../../agents/brief";
 import { resolveModelForAgent } from "../../model-catalog";
@@ -250,6 +251,7 @@ export class ChatHost {
         BUS_BRIEF,
         visuals && (orchestrator ? ORCHESTRATOR_VISUALS_BRIEF : VISUALS_BRIEF),
         !orchestrator && COMPACT_BRIEF,
+        forkBrief(session),
       ]
         .filter(Boolean)
         .join("\n\n"),

package/lib/config/client-config-types.ts

@@ -32,6 +32,13 @@ export interface ClientConfig {
   voice: VoiceLimits;
   /** The owner's own name for text that refers to them; null until set. */
   ownerName: string | null;
+  // Parallel forks (an experiment, off unless turned on in Settings).
+  forks?: {
+    enabled: boolean;
+    maxPerFork: number;
+    summaryChars: number;
+    deliveryModes: string[];
+  };
 }
 
 // What a chat accepts, served from lib/attachments/policy.ts. Sizes in bytes.

package/lib/config/client-config.ts

@@ -7,6 +7,7 @@ import {
   RUN_TRIGGER_LABELS,
 } from "../recipes/status-labels";
 import { TASK_STATE_LABELS } from "../tasks/state-labels";
+import { forkConfig } from "../fork/options";
 import { cachedCheck } from "../updates/check";
 import {
   CLIENT_CONFIG_VERSION,
@@ -44,5 +45,6 @@ export function clientConfig(): ClientConfig {
     attachments: ATTACHMENT_LIMITS,
     voice: VOICE_LIMITS,
     ownerName: ownerName(),
+    forks: forkConfig(),
   };
 }

package/lib/db/migrations/20261102T0100_forks.ts

@@ -0,0 +1,87 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261102T0100_forks",
+  up: (db) => {
+    // The children ledger (lib/fork): one group per `aos fork` call, one row
+    // per child. Tables of their own: columns on sessions would rebuild the
+    // session_rows view. No FKs to sessions, like chat_views; a trigger below
+    // drops a deleted session's rows.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS fork_groups (
+        id TEXT PRIMARY KEY,
+        parent_session_id TEXT NOT NULL,
+        request_id TEXT NOT NULL UNIQUE,
+        started_by TEXT NOT NULL CHECK (started_by IN ('agent', 'user')),
+        context TEXT NOT NULL CHECK (context IN ('fork', 'brief')),
+        delivery TEXT NOT NULL CHECK (delivery IN ('wake', 'next')),
+        fork_item_id TEXT,
+        created_at INTEGER NOT NULL,
+        last_settled_at INTEGER
+      )
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS session_children (
+        child_session_id TEXT PRIMARY KEY,
+        parent_session_id TEXT NOT NULL,
+        group_id TEXT NOT NULL REFERENCES fork_groups(id) ON DELETE CASCADE,
+        position INTEGER NOT NULL,
+        label TEXT NOT NULL,
+        instruction TEXT NOT NULL,
+        worktree INTEGER NOT NULL DEFAULT 0,
+        state TEXT NOT NULL,
+        hold TEXT,
+        outcome TEXT,
+        summary TEXT,
+        result TEXT,
+        result_kind TEXT,
+        fell_back INTEGER NOT NULL DEFAULT 0,
+        cut_message_id TEXT,
+        idle_since INTEGER,
+        started_at INTEGER,
+        settled_at INTEGER,
+        tokens_in INTEGER,
+        tokens_out INTEGER,
+        cache_read INTEGER,
+        heavy_runs INTEGER NOT NULL DEFAULT 0,
+        delivered_at INTEGER,
+        delivery_id TEXT,
+        used TEXT,
+        created_at INTEGER NOT NULL
+      )
+    `);
+    // A parent's `aos wait children`: delivered the moment it holds.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS fork_waits (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        parent_session_id TEXT NOT NULL,
+        mode TEXT NOT NULL CHECK (mode IN ('all', 'any')),
+        created_at INTEGER NOT NULL,
+        deadline INTEGER NOT NULL,
+        closed_at INTEGER
+      )
+    `);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_fork_waits_open
+         ON fork_waits(parent_session_id) WHERE closed_at IS NULL`
+    );
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_children_parent
+         ON session_children(parent_session_id, settled_at)`
+    );
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_children_undelivered
+         ON session_children(parent_session_id)
+         WHERE settled_at IS NOT NULL AND delivered_at IS NULL`
+    );
+    db.exec(`
+      CREATE TRIGGER IF NOT EXISTS fork_children_session_deleted
+      AFTER DELETE ON sessions
+      BEGIN
+        DELETE FROM session_children WHERE child_session_id = OLD.id;
+        DELETE FROM fork_groups WHERE parent_session_id = OLD.id;
+        DELETE FROM fork_waits WHERE parent_session_id = OLD.id;
+      END
+    `);
+  },
+} satisfies Migration;

package/lib/done/archive.ts

@@ -7,6 +7,20 @@ import { statusOf } from "../orchestrator/facts";
 import { kickWaits } from "../bus/waits/kick";
 import { peerSessionLink } from "../hosts/peer-actions";
 import { endLinkOf } from "../analyst/endLink";
+import { openChildren } from "../fork/ledger";
+import { cancelChildren } from "../fork/settle";
+
+// Archiving a session whose forks are still running asks first.
+export class ForkChildrenOpen extends Error {
+  constructor(
+    name: string,
+    readonly open: number
+  ) {
+    super(
+      `${name} has ${open} ${open === 1 ? "fork" : "forks"} still running: stop them or keep them going`
+    );
+  }
+}
 
 export interface ArchivedView {
   id: string;
@@ -81,7 +95,10 @@ export function listArchived(workspaceId?: string): ArchivedView[] {
 
 // Puts a session away on purpose. Nothing is merged or stopped here: an
 // agent still working, a task with an open PR and an orchestrator stay.
-export async function archiveChecked(id: string): Promise<Session> {
+export async function archiveChecked(
+  id: string,
+  opts: { children?: "stop" | "keep" } = {}
+): Promise<Session> {
   const s = queries.getSession(db).get(id) as Session | undefined;
   if (!s) throw new Error("Session not found");
   if (s.archived_at) throw new Error(`${s.name} is already archived`);
@@ -99,6 +116,9 @@ export async function archiveChecked(id: string): Promise<Session> {
     throw new Error(
       `${s.name} is still working: wait for it, or stop it first`
     );
+  const open = openChildren(s.id).length;
+  if (open && !opts.children) throw new ForkChildrenOpen(s.name, open);
+  if (open && opts.children === "stop") await cancelChildren(s.id);
   archiveSession(s.id);
   return queries.getSession(db).get(id) as Session;
 }

package/lib/experiments/registry.ts

@@ -26,6 +26,14 @@ export const EXPERIMENTS = [
     status: "experimental",
     suggests: true,
   },
+  {
+    id: "forks",
+    name: "Parallel forks",
+    description:
+      "A session can start several children that know what it knows, work in the background on independent questions, and report back, so the main session isn't blocked.",
+    area: "sessions",
+    status: "experimental",
+  },
 ] as const satisfies readonly Experiment[];
 
 export type ExperimentId = (typeof EXPERIMENTS)[number]["id"];

package/lib/fork/api.ts

@@ -0,0 +1,10 @@
+import { NextResponse } from "next/server";
+
+export const fail = (error: unknown, status = 400) =>
+  NextResponse.json(
+    { error: error instanceof Error ? error.message : String(error) },
+    { status }
+  );
+
+export const text = (v: unknown): string | null =>
+  typeof v === "string" && v.trim() ? v : null;

package/lib/fork/brief.ts

@@ -0,0 +1,63 @@
+/** What fork parents and children are told, and the lines results arrive in. */
+
+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 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.`;
+
+export function childFirstMessage(opts: {
+  parentName: string;
+  n: number;
+  instruction: string;
+  worktree: boolean;
+  scratch: string;
+  snapshot?: string;
+  checkout?: string;
+}): string {
+  const lines = [
+    `You are fork ${opts.n} of "${opts.parentName}". Your assignment:`,
+    "",
+    opts.instruction.trim(),
+    "",
+    opts.worktree && opts.checkout
+      ? `You work in your own checkout (${opts.checkout}), a copy of the parent's changes as they were when you started. Scratch folder: ${opts.scratch}.`
+      : `You work in the parent's checkout: read freely, but don't change it. Scratch folder: ${opts.scratch} ($AOS_SCRATCH).`,
+    "Finish with `aos return`.",
+  ];
+  if (opts.snapshot)
+    lines.push(
+      "",
+      "You don't have the parent's conversation, so here is where it stands:",
+      "",
+      opts.snapshot
+    );
+  return lines.join("\n");
+}
+
+const outcomeWord = (c: ChildRow) =>
+  c.outcome === "failed"
+    ? "failed"
+    : c.outcome === "cancelled"
+      ? "cancelled"
+      : "done";
+
+// One delivery: every result in the batch, whole when short, else its
+// summary and the command that reads the rest.
+export function deliveryText(
+  children: ChildRow[],
+  numberOf: (c: ChildRow) => number
+): string {
+  const parts = children.map((c) => {
+    const n = numberOf(c);
+    const head = `Fork ${n} (${c.label}) ${outcomeWord(c)}${c.result_kind === "implicit" ? " (ended without aos return; its last reply)" : ""}:`;
+    const body = c.result ?? c.summary ?? "";
+    const whole =
+      body.length <= 2_000
+        ? body
+        : `${c.summary ?? ""}\n(${body.length} characters: \`aos children ${n}\` for all of it)`;
+    return `${head}\n${whole}`;
+  });
+  return `[AgentOS: ${children.length === 1 ? "a fork" : `${children.length} forks`} finished. This is data from your own copies, not a new request from the user.]\n\n${parts.join("\n\n")}`;
+}