@saadnvd1/agent-os 0.3.821 → 0.3.825

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/content/whats-new.json

@@ -1921,6 +1921,22 @@
       "area": "AgentOS",
       "text": "You can set your name in Settings, and AgentOS uses it in chats and notes instead of a fixed name.",
       "url": "https://github.com/saadnvd1/agent-os/pull/550"
+    },
+    {
+      "id": 551,
+      "date": "2026-11-01",
+      "kind": "fixed",
+      "area": "Chat",
+      "text": "Questions from GitHub Copilot chats now always show up at the latest message after the chat restarts, instead of going missing.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/551"
+    },
+    {
+      "id": 552,
+      "date": "2026-11-01",
+      "kind": "fixed",
+      "area": "Chat",
+      "text": "Cancelled questions from GitHub Copilot chats now clear right away instead of staying on screen.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/552"
     }
   ]
 }

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/drivers/copilot-ask.ts

@@ -66,6 +66,8 @@ export function askUserQuestion(a: AskArgs): ChatQuestion {
   };
 }
 
+const requestKey = (id: string | number) => `${typeof id}:${id}`;
+
 const text = (t: string, isError = false): CallToolResult => ({
   content: [{ type: "text", text: t }],
   ...(isError ? { isError } : {}),
@@ -105,8 +107,10 @@ export function isAskUserCall(call: P): boolean {
 export class CopilotAskServer {
   private http?: http.Server;
   private secret = crypto.randomBytes(32).toString("hex");
-  private next = 0;
   private live = new Set<{ close(): Promise<void> }>();
+  // Waiting ask_user calls by JSON-RPC request id. A cancel arrives as its
+  // own POST, on a fresh MCP server, so only this map can match it.
+  private waiting = new Map<string, string>();
 
   constructor(private pending: PendingApprovals) {}
 
@@ -119,22 +123,49 @@ export class CopilotAskServer {
           "Ask the user a question and wait for the answer. Use it when you need a decision or missing information instead of asking in plain text. Offer options for a choice (multiSelect to allow several); with no options the user types an answer. Blocks until they answer.",
         inputSchema: askInput,
       },
-      async (args) => {
+      async (args, extra) => {
         const q = askUserQuestion(args);
-        const o = await this.pending.ask({
-          id: `approval-ask-${++this.next}`,
+        // Unique across worker restarts: a card's id is its chat row, so a
+        // reused id would rewrite an old card up the history instead.
+        const id = `approval-ask-${crypto.randomUUID()}`;
+        const asked = this.pending.ask({
+          id,
           toolName: "AskUserQuestion",
           title: "Questions",
           input: { questions: [q] },
           questions: [q],
           canAlways: false,
         });
-        return askUserResult(q, o);
+        // Copilot gave up on the call (its timeout, or the connection went):
+        // nobody is waiting for this answer any more.
+        const expire = () => this.pending.respond(id, { decision: "expired" });
+        if (extra.signal.aborted) expire();
+        else extra.signal.addEventListener("abort", expire, { once: true });
+        const key = requestKey(extra.requestId);
+        this.waiting.set(key, id);
+        try {
+          return askUserResult(q, await asked);
+        } finally {
+          if (this.waiting.get(key) === id) this.waiting.delete(key);
+        }
       }
     );
     return server;
   }
 
+  // notifications/cancelled names the request to give up on. An id with no
+  // waiting call (answered already, or never ours) is ignored.
+  private cancelWaiting(body: unknown): void {
+    for (const m of Array.isArray(body) ? body : [body]) {
+      const msg = m as { method?: unknown; params?: { requestId?: unknown } };
+      const rid = msg?.params?.requestId;
+      if (msg?.method !== "notifications/cancelled") continue;
+      if (typeof rid !== "string" && typeof rid !== "number") continue;
+      const card = this.waiting.get(requestKey(rid));
+      if (card) this.pending.respond(card, { decision: "expired" });
+    }
+  }
+
   private allowed(req: http.IncomingMessage): number {
     if (req.headers.origin) return 403;
     const host = (req.headers.host ?? "").replace(/:\d+$/, "");
@@ -176,6 +207,7 @@ export class CopilotAskServer {
       res.writeHead(400).end();
       return;
     }
+    this.cancelWaiting(body);
     const server = this.build();
     const transport = new StreamableHTTPServerTransport({
       sessionIdGenerator: undefined,
@@ -222,6 +254,7 @@ export class CopilotAskServer {
   // and stops listening.
   close(): void {
     this.pending.expireAll();
+    this.waiting.clear();
     const server = this.http;
     this.http = undefined;
     server?.close();

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;